Refactorisation du code avec GitHub Copilot

Introduction

La refactorisation du code est le processus de restructuration du code existant sans modifier son comportement. Les avantages de la refactorisation incluent l’amélioration de la lisibilité du code, la réduction de la complexité, la facilité de maintenance du code et l’ajout de nouvelles fonctionnalités plus facilement.

Cet article vous donne quelques idées d’utilisation de Copilot pour refactoriser le code dans votre IDE.

Note

Les exemples de réponses sont inclus dans cet article. GitHub Copilot Chat peuvent vous donner des réponses différentes de celles indiquées ici.

Compréhension du code

Avant de modifier le code existant, vous devez vous assurer que vous comprenez son objectif et comment il fonctionne actuellement. Copilot peut vous aider pour cela.

Sélectionnez le code approprié dans l’éditeur de votre IDE.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).
Dans la zone d’entrée pour la conversation inline, tapez une barre oblique (/).
Dans la liste déroulante, sélectionnez /explain et appuyez sur Entrée.
Si l’explication que Copilot renvoie est supérieure à quelques lignes, cliquez sur Afficher dans la conversation pour vous permettre de lire plus facilement l’explication.

Optimisation du code inefficace

Copilot peuvent vous aider à optimiser le code, par exemple pour rendre le code exécuté plus rapidement.

Exemple de code

Dans les deux sections ci-dessous, nous allons utiliser l’exemple de script bash suivant pour illustrer comment optimiser le code inefficace :

#!/bin/bash

# Find all .txt files and count lines in each
for file in $(find . -type f -name "*.txt"); do
    wc -l "$file"
done

Utilisez le volet Copilot Chat

Copilot peut vous indiquer si le code, comme l’exemple de script bash, peut être optimisé.

Sélectionnez la boucle for ou le contenu entier du fichier.
Ouvrez Copilot Chat en cliquant sur l’icône de conversation dans la barre d’activité ou en utilisant le raccourci clavier :
- VS Code et Visual Studio : Ctrl+Command+i (Mac) / Ctrl+Alt+i (Windows/Linux)
- JetBrains : Ctrl+Maj+c
Dans la zone d’entrée située en bas du panneau de conversation, tapez : Can this script be improved?

Copilot répond avec une suggestion qui rendra le code plus efficace.
Pour appliquer la modification suggérée :
- Dans VS Code et JetBrains : pointez sur la suggestion dans le volet de conversation, puis cliquez sur l’icône Insérer au curseur.
- Dans Visual Studio : cliquez sur Aperçu , puis, dans la vue comparaison, cliquez sur Accepter.

Utiliez la conservation inline Copilot

Sinon, si vous savez déjà que le code existant, comme l’exemple de script bash, est inefficace :

Sélectionnez la boucle for ou le contenu entier du fichier.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).
Tapez optimize, puis appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :
```
find . -type f -name "*.txt" -exec wc -l {} +
```
Cela est plus efficace que le code d’origine, indiqué précédemment dans cet article, car l’utilisation de -exec ... + permet à find de passer plusieurs fichiers wc la fois plutôt que d’appeler wc une seule fois pour chaque fichier *.txt trouvé.
Évaluez les suggestions Copilot et, si vous acceptez la modification :
- Dans VS Code et Visual Studio : cliquez sur Accepter.
- Dans JetBrains : cliquez sur l’icône Aperçu (flèches doubles), puis sur l’icône Appliquer tous les différences (crochets doubles).

Comme avec toutes les suggestions Copilot, vous devez toujours vérifier que le code révisé s’exécute sans erreurs et produit le résultat correct.

Nettoyage du code répété

Éviter la répétition facilite la révision et le débogage de votre code. 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 applesSold = 100;
totalSales += applePrice * applesSold;

let orangePrice = 5;
let orangesSold = 50;
totalSales += orangePrice * orangesSold;

console.log(`Total: ${totalSales}`);

Vous pouvez demander à Copilot de déplacer le calcul répété dans une fonction.

Sélectionnez le contenu du document.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).

Tapez : move repeated calculations into functions, puis appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :

function calculateSales(price, quantity) {
  return price * quantity;
}

let totalSales = 0;

let applePrice = 3;
let applesSold = 100;
totalSales += calculateSales(applePrice, applesSold);

let orangePrice = 5;
let orangesSold = 50;
totalSales += calculateSales(orangePrice, orangesSold);

console.log(`Total: ${totalSales}`);

Évaluez les suggestions Copilot et, si vous acceptez la modification :
- Dans VS Code et Visual Studio : cliquez sur Accepter.
- Dans JetBrains : cliquez sur l’icône Aperçu (flèches doubles), puis sur l’icône Appliquer tous les différences (crochets doubles).

Comme avec toutes les suggestions Copilot, vous devez toujours vérifier que le code révisé s’exécute sans erreurs et produit le résultat correct.

Rendre le code plus concis

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

Dans l’exemple suivant, ce code Python génère la zone d’un rectangle et d’un cercle, mais peut être écrit plus concisément :

def calculate_area_of_rectangle(length, width):
    area = length * width
    return area

def calculate_area_of_circle(radius):
    import math
    area = math.pi * (radius ** 2)
    return area

length_of_rectangle = 10
width_of_rectangle = 5
area_of_rectangle = calculate_area_of_rectangle(length_of_rectangle, width_of_rectangle)
print(f"Area of rectangle: {area_of_rectangle}")

radius_of_circle = 7
area_of_circle = calculate_area_of_circle(radius_of_circle)
print(f"Area of circle: {area_of_circle}")

Sélectionnez le contenu du document.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).

Tapez : make this more concise, puis appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :

import math

def calculate_area_of_rectangle(length, width):
  return length * width

def calculate_area_of_circle(radius):
  return math.pi * (radius ** 2)

print(f"Area of rectangle: {calculate_area_of_rectangle(10, 5)}")
print(f"Area of circle: {calculate_area_of_circle(7)}")

Évaluez les suggestions Copilot et, si vous acceptez la modification :
- Dans VS Code et Visual Studio : cliquez sur Accepter.
- Dans JetBrains : cliquez sur l’icône Aperçu (flèches doubles), puis sur l’icône Appliquer tous les différences (crochets doubles).

Comme avec toutes les suggestions Copilot, vous devez toujours vérifier que le code révisé s’exécute sans erreurs et produit le résultat correct.

Fractionnement d’unités complexes de code

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

Copilot peuvent vous aider à fractionner des blocs complexes de code 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.style import Styler

def process_data(item, price):
    # Cleanse data
    item = item.strip()  # Strip whitespace from item
    price = price.strip()  # Strip whitespace from price
    price = float(price) # Convert price to a float
    # More cleansing operations 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.25"
process_data(item, price)

Pour fractionner la fonction process_data :

Placez le curseur dans le nom de la fonction.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).

Tapez : split into 2 separate functions: one for cleansing data, the other for printing, puis appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :

def cleanse_data(item, price):
  # Cleanse data
  item = item.strip()  # Strip whitespace from item
  price = price.strip()  # Strip whitespace from price
  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)

Note

L’exemple de suggestion présenté ci-dessus remplace la fonction existante par trois fonctions. La troisième fonction appelle simplement les deux autres fonctions et autorise le code existant qui appelle la fonction process_data.

Évaluez les suggestions Copilot et, si vous acceptez la modification :
- Dans VS Code et Visual Studio : cliquez sur Accepter.
- Dans JetBrains : cliquez sur l’icône Aperçu (flèches doubles), puis sur l’icône Appliquer tous les différences (crochets doubles).

Comme avec toutes les suggestions Copilot, vous devez toujours vérifier que le code révisé s’exécute sans erreurs et produit le résultat correct.

Réécrire le code conditionnel pour une meilleure 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’usage particuliers, et le choix d’une autre structure conditionnelle peut parfois faciliter la lecture du code.

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

public String getSound(String animal) {
  if (animal == null) {
      System.out.println("Oops! A null animal?");
  } 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.

Placez le curseur dans le nom de la méthode.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).
Entrez : rewrite the condition to use a switch and use Java 21 syntax with null case, but also add documentation and provide a better function name.

Cela montre comment vous pouvez utiliser une invite unique pour demander à Copilot d’apporter plusieurs modifications.

Appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :

/**
 * Retrieves the sound made by a given 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 -> {
            System.out.println("Oops! A null animal?");
            yield "Unknown";
        }
        case String a when a.equalsIgnoreCase("Dog") -> "Bark";
        case String a when a.equalsIgnoreCase("Cat") -> "Meow";
        case String a when a.equalsIgnoreCase("Bird") -> "Tweet";
        default -> "Unknown";
    };
}

Évaluez les suggestions Copilot et, si vous acceptez la modification :
- Dans VS Code et Visual Studio : cliquez sur Accepter.
- Dans JetBrains : cliquez sur l’icône Aperçu (flèches doubles), puis sur l’icône Appliquer tous les différences (crochets doubles).

Comme avec toutes les suggestions Copilot, vous devez toujours vérifier que le code révisé s’exécute sans erreurs et produit le résultat correct.

Code reformat pour utiliser une autre structure

Supposons que vous disposiez de cette fonction en JavaScript :

function listRepos(o, p) {
 return fetch(`https://api.github.com/orgs/${o}/repos?per_page=${parseInt(p)}`)
   .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 Copilot pour vous aider à apporter ces modifications.

Placez le curseur dans le nom de la fonction.
Ouvrez la conversation inline :
- Dans VS Code : appuyez sur Commande+i (Mac) ou Ctrl+i (Windows/Linux).
- Dans Visual Studio : appuyez sur Alt+/.
- Dans JetBrains IDEs : appuyez sur Ctrl+Maj+i (Mac) ou Ctrl+Maj+g (Windows/Linux).

Tapez : use arrow notation and better parameter names, puis appuyez sur Entrée.

Copilot suggère un code révisé. Par exemple :

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

Amélioration du nom d’un symbole

Note

VS Code et Visual Studio uniquement.
La prise en charge de cette fonctionnalité dépend de l’installation de l’extension de langage appropriée dans votre IDE pour la langue que vous utilisez. Toutes les extensions de langage ne prennent pas en charge cette fonctionnalité.

Les noms bien choisis peuvent aider à faciliter la maintenance du code. Copilot dans VS Code et Visual Studio peuvent suggérer d’autres noms pour des symboles tels que des variables ou des fonctions.

Placez le curseur dans le nom du symbole.
Appuyez sur F2.
Visual Studio uniquement : appuyez sur Ctrl+Espace.

Copilot suggère d’autres noms.
Dans la liste déroulante, sélectionnez l’un des noms suggérés.

Le nom est modifié par le biais du projet.

Refactorisation du code avec GitHub Copilot

Dans cet article