Comment réviser et refactoriser le code avec GPT-4 (et ChatGPT) —

Il est temps d’améliorer votre processus de codage avec l’amélioration du code pilotée par l’IA. La famille de modèles GPT d’OpenAI offre aux développeurs une multitude d’opportunités pour améliorer, réviser, corriger et même externaliser l’écriture de code. Savoir utiliser ces grands modèles de langage pendant le processus de développement deviendra bientôt un outil essentiel dans la boîte à outils du développeur.

Vous êtes-vous déjà demandé comment l’IA pourrait transformer votre processus de codage ? Dans ce guide, nous allons démontrer des techniques d’utilisation de ChatGPT ou GPT-4 pour réviser et refactoriser le code, ainsi que discuter de certaines limitations et fournir des ressources pratiques pour utiliser ces LLM dans votre flux de travail de programmation.

Nous commencerons par les façons dont nous pouvons examiner et refactoriser, et pour chacun d’entre eux, vous voudrez peut-être expérimenter différentes invites et les techniques fournies pour libérer tout le potentiel d’amélioration du code basé sur l’IA.

Remarque : J’utiliserai le terme GPT4 dans le contenu car il s’agit du modèle actuel demandé pour les exemples contenus. ChatGPT (GPT3.5) fonctionne de manière similaire et peut être utilisé de manière interchangeable.

Code de refactorisation avec GPT-4 et ChatGPT

La refactorisation du code est cruciale pour plusieurs raisons : elle améliore la lisibilité et la maintenabilité, ce qui permet aux développeurs de comprendre et de modifier plus facilement le code. Cela aide également à prévenir les bogues potentiels et garantit que votre code respecte les meilleures pratiques établies. En fin de compte, la refactorisation peut conduire à des logiciels plus efficaces, fiables et robustes.

GPT-4 peut contribuer de manière significative à ce processus. En utilisant GPT-4 pour examiner et évaluer votre code, vous pouvez identifier rapidement les domaines à améliorer et créer un code plus propre et plus efficace. L’exploitation des capacités de GPT-4 peut faire gagner du temps et réduire les erreurs humaines dans le processus, ce qui se traduit par un respect plus cohérent des normes de codage.

Modernisation de l’ancien code

Vous pouvez rapidement moderniser votre code en fournissant votre ancienne fonction à GPT-4 et lui demander de le refactoriser selon les pratiques de codage modernes.

Rapide: Refactor the following code to modern es6 programming standards

Avant:

function tempConvert(temp, scale) { 
  var result = 0; 
  if (scale == "C") { 
    result = (temp - 32) * (5 / 9); 
  } else {
    result = (temp * (9 / 5)) + 32;
  }
  return result.toFixed(1) + "°" + (scale == "C" ? "F" : "C"); 
}

Après:

const tempConvert = (temp, scale) => {
  const isValidScale = scale === "C" || scale === "F";
  if (!isValidScale) {
    throw new Error("Invalid scale: must be 'C' or 'F'.");
  }

  const conversionFactor = 5 / 9;
  const result = scale === "C"
    ? (temp - 32) * conversionFactor
    : (temp * conversionFactor) + 32;

  const resultUnit = scale === "C" ? "F" : "C";
  return `${result.toFixed(1)}°${resultUnit}`;
}

Dans cette version refactorisée, GPT4 a rapidement apporté les améliorations suivantes :

1. Ajout de commentaires JSDoc
2. converti le tempConvert fonction à une fonction fléchée.
3. Remplacé var avec const pour les variables immuables.
4. Utilisation de contrôles d’égalité stricte (===) pour les comparaisons de chaînes.
5. Introduction d’une constante pour éliminer les nombres magiques.
6. Simplification de l’instruction de retour avec des littéraux de modèle.

Ajout de bonnes pratiques ou de principes de codage

Votre organisation ou votre base de code peut utiliser certaines pratiques et certains styles de codage que vous souhaitez conserver. Pour de telles situations, fournissez des instructions à GPT4 sur la pratique de codage particulière ou le style sur lequel vous souhaitez qu’il se concentre.

Rapide: Review the following code and refactor it to make it more DRY and adopt the SOLID programming principles.

Notez qu’avec la même contribution, il a adopté le principe de programmation SOLID de Responsabilité unique et divisez la fonction en 3. Contrairement à l’étape « Moderniser » précédente, elle n’a pas converti la fonction en fonction fléchée.

« En extrayant la logique de conversion en fonctions distinctes, nous avons amélioré l’adhésion du code au principe de responsabilité unique (partie de SOLID), car chaque fonction a désormais un objectif clair et ciblé. »

function tempConvert(temp, scale) {
  const isValidScale = scale === "C" || scale === "F";
  if (!isValidScale) {
    throw new Error("Invalid scale: must be 'C' or 'F'.");
  }

  const result = scale === "C" ? celsiusToFahrenheit(temp) : fahrenheitToCelsius(temp);
  const resultUnit = scale === "C" ? "F" : "C";
  return `${result.toFixed(1)}°${resultUnit}`;
}

function celsiusToFahrenheit(temp) {
  const conversionFactor = 9 / 5;
  return (temp * conversionFactor) + 32;
}

function fahrenheitToCelsius(temp) {
  const conversionFactor = 5 / 9;
  return (temp - 32) * conversionFactor;
}

Détecter et corriger les erreurs

Parfois, nous sommes aveugles aux vulnérabilités ou aux problèmes potentiels que notre code peut créer. Faire en sorte que GPT-4 examine et résolve les problèmes de code peut vous faire gagner plus que du temps.

Rapide: Review this code for errors and refactor to fix any issues...

Fonction d’entrée (imparfaite) :

function updateTotalPrice(items, discountPercentage) {
  let totalPrice = 0;

  for (let i = 0; i < items.length; i++) {
    const item = items[i];
    totalPrice += item.price * item.quantity;
  }

  
  const discount = totalPrice * (discountPercentage / 100);
  totalPrice -= discount;

  return totalPrice;
}

Sortir:

function updateTotalPrice(items, discountPercentage) {
  
  if (!Array.isArray(items) || typeof discountPercentage !== 'number') {
    throw new Error('Invalid input parameters');
  }

  
  if (discountPercentage < 0 || discountPercentage > 100) {
    throw new Error('Invalid discount percentage value. It should be between 0 and 100');
  }

  let totalPrice = 0;

  for (let i = 0; i < items.length; i++) {
    const item = items[i];
    
    
    if (!item.hasOwnProperty('price') || !item.hasOwnProperty('quantity') || 
        typeof item.price !== 'number' || typeof item.quantity !== 'number') {
      throw new Error('Invalid item properties');
    }

    totalPrice += item.price * item.quantity;
  }

  const discount = totalPrice * (discountPercentage / 100);
  totalPrice -= discount;

  return totalPrice;
}

Modifications apportées par GPT-4 :

1. Ajout de la validation des paramètres d’entrée pour s’assurer que les éléments sont un tableau et que discountPercentage est un nombre.
2. Conditions aux limites vérifiées pour discountPercentage afin de s’assurer qu’il se situe dans la plage 0-100.
3. Ajout de la validation des propriétés des articles et de leurs types pour garantir que le prix et la quantité sont des nombres.

Créer un code standard (* mon préféré)

Commencer de nouveaux projets peut être pénible. GPT-4 ne connaît pas votre logique métier, mais il peut être utilisé pour lancer le code passe-partout ennuyeux le premier jour. Ce n’est pas techniquement refactoring mais c’est incroyable et cela peut faire partie d’un processus dans le cycle de vie de la programmation.

Rapide: Write me a boilerplate Node.js function that will take a variable of type User, validate that the user has the right permissions, fetch an array of item type Posts from a postgres database and return them. Leave comments for business logic.

Code de transpilation

Il existe de nombreuses raisons pour lesquelles vous devrez peut-être convertir du code d’une langue à une autre. Vous avez trouvé un dépôt avec du code pour un langage dont vous avez besoin dans un autre, vous déplacez des bases de code, ou peut-être que votre patron a lu un article sur le dernier framework frontal et maintenant vous passez à {divisive new library}.

Dans tous les cas, GPT-4 peut fournir une assistance avec une simple invite.

Rapide: Rewrite the following code in Rust: ...

Si votre code est explicite mais nécessite des commentaires, cela peut être un énorme gain de temps.

Rapide: Add comments to the following code ...

Conseils pour une meilleure refactorisation

Comme beaucoup de choses dans la vie, avec GPT-4, vous obtenez ce que vous avez mis. Dans ce cas, fournir plus de contexte, d’instructions et de conseils produira généralement de meilleurs résultats.

Voici une courte liste de conseils et de techniques pour améliorer votre refactorisation de code :

• Divisez vos invites : Essayez de diviser vos invites et le résultat souhaité en plusieurs étapes. Garder les invites pour avoir un seul résultat s’est avéré produire de meilleurs résultats que les invites combinées. Par exemple, demandez une révision, puis demandez une refactorisation basée sur la réponse de la révision. Cela peut devenir moins important avec le temps à mesure que les LLM augmentent leur limite de jetons.
• Être spécifique: N’ayez pas peur d’énumérer exactement ce que vous voulez, ce que vous savez, ce dont vous avez besoin et ce qu’il ne faut pas inclure.
• Demandez-lui de réfléchir : Une technique appelée réflexion a été montré pour augmenter la précision de GPT4. En gros, demandez-lui « Pourquoi vous êtes-vous trompé ? » ou l’amener à réfléchir et à revoir sa propre réponse.

Limites

Cet article est très pro-IA, cependant ces modèles ne sont pas parfaits et ne peuvent pas (encore) reproduire fidèlement la logique métier, entre autres. Voici une liste de choses à surveiller et à éviter lors de l’utilisation de GPT-4 pour réviser ou refactoriser votre code :

• Cela peut être (en toute confiance) faux : GPT4 est formé pour sembler convaincant, mais cela ne signifie pas qu’il a toujours raison. Encore un super article sur refactoriser Golang avec ChatGPT signalé ‘Il s’est débarrassé des vérifications de type avec l’explication confiante que l’affirmation de type d’une valeur non int à un type int renverra la valeur zéro pour le type int, mais ce n’est pas correct et va paniquer‘.
• Gagner du temps au départ peut ne pas en valoir la peine à long terme : Bien sûr, GPT4 peut vous générer 50 lignes de code en une minute, mais cela peut vous prendre 45 minutes pour le déboguer et le modifier s’il n’est pas adapté à votre base de code. Vous auriez mieux fait de l’écrire vous-même.
• Il peut être obsolète : Le monde de la technologie évolue rapidement. « GPT-4 manque généralement de connaissance des événements qui se sont produits après la grande majorité de ses données coupées (septembre 2021)« . Vous pouvez rencontrer des problèmes avec toute bibliothèque, infrastructure ou technologie récemment mise à jour.

Conclusion

La programmation alimentée par l’IA n’est que nouvelle, mais elle est là pour rester. Lorsqu’il est utilisé correctement, il peut faire gagner du temps et nous aider à écrire un meilleur code. J’espère que vous avez apprécié cet article et que vous avez acquis de nouvelles compétences pour augmenter votre productivité en programmation ou la gestion des erreurs.