Analyser une logique complexe à l’aide du mode Demander de GitHub Copilot

  • 8 minutes

L’identification de conditions complexes qui peuvent et doivent être simplifiées n’est pas toujours facile. La planification de la refactorisation de votre code peut être encore plus difficile.

Les développeurs peuvent utiliser le mode Demander de GitHub Copilot pour refactoriser des conditions complexes et améliorer la qualité du code.

Qu’est-ce que le mode Demander ?

Le mode Ask de GitHub Copilot est une interface de conversation conversationnelle. Vous posez des questions et GitHub Copilot vous répond en utilisant le contexte que vous fournissez. C’est comme avoir un collègue compétent qui peut lire votre code et donner des conseils. Par exemple, vous pouvez utiliser le mode Demander pour expliquer ce qu’une fonction fait, identifier les problèmes potentiels ou suggérer des améliorations.

Le mode Demander répond avec des explications, des insights ou des exemples de code que vous pouvez utiliser pour améliorer votre code. En mode Demander, GitHub Copilot n’apporte aucune modification à vos fichiers de code.

Analyser des conditions complexes à l’aide du mode Demander

Vous pouvez utiliser le mode Demander pour identifier et analyser des conditions complexes dans votre code. GitHub Copilot peut vous aider à comprendre la logique conditionnelle, à identifier les problèmes potentiels et à évaluer les opportunités d’amélioration.

Stratégies d’analyse des conditions complexes

Voici quelques stratégies d’utilisation du mode Demander pour analyser des conditions complexes :

  • Expliquez le code : Demandez à GitHub Copilot d’expliquer ce que fait le conditionnel complexe. Cette question vous permet de vous assurer que vous comprenez la logique actuelle avant d’apporter des modifications.

  • Identifier la complexité : Demandez à GitHub Copilot d’identifier les parties du conditionnel qui le rendent complexe. Cette question peut vous aider à identifier les domaines sur lesquels se concentrer.

  • Rechercher des cas de périphérie : Demandez à GitHub Copilot d’identifier les cas de périphérie ou les bogues potentiels dans la logique conditionnelle. Cette question peut vous aider à vous assurer que votre code refactorisé gère tous les scénarios.

  • Suggérer une refactorisation : Demandez à GitHub Copilot des suggestions sur la façon de simplifier ou de refactoriser la logique conditionnelle. GitHub Copilot peut suggérer l’utilisation de clauses de protection, d’extraction de méthodes ou d’autres techniques pour améliorer la clarté.

  • Demandez des exemples : si vous ne savez pas comment implémenter une suggestion, demandez à GitHub Copilot pour obtenir des exemples de code. Cette question peut vous aider à comprendre comment appliquer les conseils dans votre contexte spécifique.

  • Explorer les risques : Demandez à GitHub Copilot des risques potentiels ou des effets secondaires de la refactorisation de la logique conditionnelle. Cette question peut vous aider à éviter d’introduire de nouveaux bogues.

  • Itérer : utilisez des questions de suivi pour approfondir des suggestions ou des types de problème spécifiques. Une approche itérative peut vous aider à affiner votre compréhension et à planifier votre approche plus efficacement.

Requêtes de mode Demander pour les conditions complexes

Les instructions que vous utilisez pour analyser des conditionnels complexes doivent refléter votre code et vos objectifs spécifiques. Toutefois, voici quelques bonnes pratiques suggérées à prendre en compte :

  • Concentrez-vous sur des techniques d’analyse spécifiques plutôt que sur des demandes d’aide génériques.
  • Référencez les pratiques établies comme les principes SOLID, les modèles de conception et les conventions de codage.
  • Incluez des métriques de qualité telles que la complexité cyclomatique et les odeurs de code.
  • Mettez l’accent sur les tests et l’atténuation des risques, ce qui est essentiel pour la refactorisation sécurisée.
  • Promouvoir les meilleures pratiques pour le code sécurisé, gérable et lisible.
  • Encouragez une réflexion systématique sur les exigences métier et l’implémentation technique.
  • Le cas échéant, traitez les considérations relatives aux performances qui sont importantes pour le code de production.

Établir le contexte de conversation requis

Lorsque vous utilisez le mode Demander, il est important de fournir un contexte suffisant pour GitHub Copilot afin de comprendre le code que vous analysez. Voici quelques conseils :

  • Utilisez le bouton Ajouter un contexte dans l’interface de conversation pour inclure des fichiers ou dossiers pertinents à partir de votre codebase.
  • Incluez des extraits de code ou des exemples pertinents qui illustrent vos points.
  • Décrivez les objectifs spécifiques que vous avez pour l’analyse (par exemple, la simplification de la logique, l’identification des bogues).
  • Mentionnez toutes les contraintes ou exigences importantes pour l’analyse (par exemple, considérations relatives aux performances, normes de codage).

Voici quelques exemples de texte en langage naturel que vous pouvez inclure dans votre invite lors de l’analyse de conditions complexes :

Compréhension et analyse

  • « Analysez la logique conditionnelle sélectionnée et expliquez ce que fait chaque branche ».
  • « Quelle est la complexité cyclomatique du bloc conditionnel sélectionné et pourquoi ? »
  • « Passez en revue le conditionnel sélectionné et identifiez les principales conditions évaluées et leurs relations. »
  • « Quelles sont les règles d’entreprise ou les exigences que la logique conditionnelle sélectionnée implémente ? »

Évaluation de la qualité

  • « Évaluez le conditionnel sélectionné pour les problèmes de maintenance potentiels. »
  • « Existe-t-il des odeurs de code ou des anti-modèles dans la logique conditionnelle sélectionnée ? »
  • « Passez en revue le conditionnel sélectionné et identifiez les cas limites ou les conditions d’erreur qui pourraient ne pas être correctement gérées. »
  • « Le conditionnel sélectionné respecte-t-il les principes SOLID ? Si ce n’est pas le cas, comment pourrait-il être amélioré ?

Opportunités de refactorisation

  • « Suggérer des techniques de refactorisation spécifiques pour simplifier le conditionnel sélectionné (clauses de garde, polymorphisme, modèle de stratégie, etc.). »
  • « Comment puis-je décomposer la condition complexe sélectionnée dans des fonctions plus petites et plus ciblées ? »
  • « Quels modèles de conception pourraient aider à éliminer ou à réduire la complexité du conditionnel sélectionné ? »
  • « Montrez-moi comment appliquer le principe « échec rapide » à la logique conditionnelle sélectionnée.

Test et évaluation des risques

  • « Quels cas de test dois-je vérifier que la logique conditionnelle sélectionnée fonctionne correctement après la refactorisation ? »
  • « Quels sont les risques de refactorisation du conditionnel sélectionné et comment puis-je les atténuer ? »
  • « Comment puis-je vérifier que le code refactorisé conserve le même comportement que l’original ? »
  • « Passez en revue vos approches suggérées pour refactoriser le conditionnel sélectionné. Quelles sont les implications en matière de performances associées à chacune des approches suggérées ? »

Meilleures pratiques d’application

  • « La condition sélectionnée suit-elle les conventions de codage C# de Microsoft ? Quelles améliorations sont nécessaires ? »
  • « Comment faire en sorte que le conditionnel sélectionné soit plus lisible et auto-documenté ? »
  • « Quelles améliorations apportées au nommage rendraient la logique conditionnelle sélectionnée plus claire ? »
  • « Comment puis-je réduire la charge cognitive lors de la lecture du conditionnel sélectionné ? »

Workflow de mode Demander pour les conditions complexes

Le flux de travail suivant montre comment utiliser le mode Ask sur un conditionnel complexe :

  1. Ouvrir le code problématique

    Accédez au fichier et à la fonction qui contient la logique conditionnelle complexe que vous envisagez de refactoriser. Par exemple, supposons que vous disposez d’une méthode CalculateDiscount() qui s’est développée au fil du temps avec de nombreuses conditions imbriquées.

  2. Sélectionner le code approprié

    En sélectionnant le bloc de code spécifique (les instructions imbriquées if , par exemple), vous donnez à Copilot un focus clair. Copilot utilise cette sélection comme contexte pour répondre.

  3. Demander une explication du code

    Commencez avec la simplicité à l’esprit. Exemple :

    « Copilot, pouvez-vous expliquer ce que fait cette CalculateDiscount méthode ? »

    En mode Ask, Copilot lit le code et produit une explication en anglais brut. Cette étape est utile pour vous assurer que vous (et GitHub Copilot) comprenez entièrement la logique actuelle avant de la modifier. L’explication peut revenir comme suit :

    « Cette méthode calcule une remise pour une commande. Tout d’abord, il vérifie si l’utilisateur est un membre Premium ; si c’est le cas, il définit baseDiscount sur 10%. Ensuite, il vérifie si un code de coupon est fourni. S’il existe un coupon, il valide la date d’expiration du coupon, en appliquant une remise supplémentaire si elle est valide. Il a également des cas spéciaux pour les ventes de vacances et les commandes en bloc...

    Utilisez l’explication pour confirmer l’intention du code. L'explication peut même identifier où la logique est tortueuse.

  4. Poser des questions pointées sur la complexité

    Vous pouvez maintenant devenir analytique. Exemple :

    • « Existe-t-il des vérifications redondantes ou répétées dans ce code ? »
    • « Quelles parties de cette logique rendent-elles complexes ? »
    • « Quels sont les cas de périphérie gérés par ce code ? »

    Utilisez les réponses de GitHub Copilot pour identifier les opportunités d’amélioration. Par exemple:

    « L’élément imbriqué if à l’intérieur de la section coupon ajoute à la complexité. » De plus, il existe cinq niveaux if de profondeur pour les soldes de fin d’année – pensez à simplifier cela. »

    Utilisez les commentaires pour poursuivre votre analyse.

  5. Demander des suggestions de refactorisation

    Maintenant, la question clé :

    « Comment puis-je simplifier ou refactoriser cette logique conditionnelle ? »

    Copilot, en mode Demander, peut répondre avec une liste de suggestions. Par exemple:

    • Utilisez des clauses de garde pour gérer les cas où aucune remise ne s’applique (par exemple, si le coupon n’est pas valide, retourner tôt).
    • Extrayez la validation des coupons et le calcul de remise dans sa propre fonction pour plus de clarté.
    • Combinez les deux contrôles de membre Premium distincts dans un seul endroit pour éviter la duplication.
    • Utilisez un switch ou un dictionnaire pour les multiplicateurs des ventes de fin d’année au lieu de if/else.

    Il peut même esquisser un bref pseudo-code ou montrer comment un élément du code s’occuperait de l’application de ces idées.

  6. Itérer par des questions de suivi

    Vous pouvez approfondir n’importe quelle suggestion :

    • « Quelles conditions dans cette fonction seraient de bonnes clauses de garde ? »
    • « Pouvez-vous me montrer à quoi ressemble une fonction extraite pour le calcul des coupons ? »
    • « Quels sont les différents scénarios de remise que ce code prend en compte ? »

    Grâce à ce dialogue, GitHub Copilot permet de former un plan de refactorisation. À la fin de l’exploration en mode Ask, vous pouvez avoir une liste de modifications spécifiques à implémenter, telles que :

    • Ajoutez un retour anticipé pour les coupons non valides.
    • Déplacer le calcul de remise de vacances vers une fonction distincte.
    • Supprimez la vérification dupliquée sur IsPremium en la faisant une seule fois en haut.
    • Utilisez une condition combinée unique pour les commandes en bloc au lieu de deux instructions imbriquées if .

Cette approche structurée permet de garantir que toute refactorisation conserve l’intention d’origine tout en améliorant la clarté et la facilité de maintenance du code.

Traiter les suggestions GitHub Copilot comme conseils

Bien que les suggestions de GitHub Copilot soient souvent bonnes, elles ne sont pas infaillibles. Traitez-les comme des conseils, pas une vérité absolue. Par exemple, GitHub Copilot peut suggérer une modification qui modifierait légèrement le comportement s’il a mal interprété le code. Vérifiez toujours toutes les modifications de logique critique.

Étant donné que le mode Ask ne modifie pas votre code, vous êtes libre d’explorer différentes approches et d’évaluer des suggestions sans risque.

Résumé

L’utilisation du mode Ask de GitHub Copilot est un moyen puissant d’analyser et de planifier la refactorisation des conditions complexes. En vous engageant de manière conversationnelle, vous pouvez obtenir des insights sur la logique existante, identifier les points de douleur et recevoir des suggestions personnalisées pour simplifier. Cette approche permet de garantir que toute refactorisation conserve l’intention d’origine tout en améliorant la clarté et la facilité de maintenance du code.