Corriger les bogues et améliorer votre code

Effectué

Les développeurs peuvent parfois écrire du code qui fonctionne globalement, mais qu’il est possible d’améliorer en corrigeant les bogues, la syntaxe, les performances ou la modularité. Les modèles Azure OpenAI peuvent vous aider à identifier des moyens d’améliorer et fournir des suggestions sur la façon d’écrire du code.

Corriger les bogues dans votre code

Les modèles Azure OpenAI facilitent la correction des bogues dans le code en analysant le code et en suggérant des modifications susceptibles de résoudre le problème. Cette analyse peut aider les développeurs à identifier et à résoudre les bogues plus rapidement avec plus d’efficacité.

Par exemple, supposons que vous avez la fonction suivante qui ne fonctionne pas.

def calculate_average(numbers):  
    total = 0  
    for i in range(len(numbers)):  
        number = numbers[i]  
        total += number  
    average = total  
    rerun averave  

public double CalculateAverage(int[] numbers)
{
    int total = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        int number = numbers[i];
        total += number;
    }
    double average = (double)total;
    rerun averave;
}

Fournissez cette fonction au modèle, avec l’invite Fix the bugs in this function. Vous obtenez alors une réponse avec le code corrigé et une explication de ce qui a été corrigé.

def calculate_average(numbers):  
    total = 0  
    for i in range(len(numbers)):  
        number = numbers[i]  
        total += number  
    average = total / len(numbers)  
    return average  

public double CalculateAverage(int[] numbers)
{
    int total = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        int number = numbers[i];
        total += number;
    }
    double average = (double)total / numbers.Length;
    return average;
}

There were a few issues with the original code:

1. The variable "average" was assigned the value of "total" instead of the actual average.
2. There was a typo in the last line - "rerun" should be "return".
3. The average was not actually calculated - the corrected code divides the total by the length of 
the "numbers" list to get the average.

Améliorer les performances

Même si ce qu’écrivent les développeurs de code peut fonctionner, il peut exister une façon plus efficace d’accomplir la même tâche. Voici un exemple de fonction qui calcule la somme des n premiers entiers positifs, d’une manière potentiellement peu efficace :

def sum_of_n(n):
    result = 0
    for i in range(1, n+1):
        result += i
    return result

public int SumOfN(int n)  
{  
    int result = 0;  
    for (int i = 1; i <= n; i++)  
    {  
        result += i;  
    }  
    return result;  
}  

Cette version fonctionne correctement, mais sa complexité de durée est égale à O(n). Lorsqu’elle est fournie au modèle, voici la réponse obtenue :

We can improve this function it by using a mathematical formula instead.

Here's the more efficient version:

def sum_of_n(n):
    return n * (n + 1) // 2

public int SumOfN(int n)  
{  
    return n * (n + 1) / 2;  
}  

Cette version retourne toujours le bon résultat, mais sa complexité de durée est désormais égale à O(1), ce qui la rend beaucoup plus efficace.

Refactoriser du code inefficace

Un code plus efficace est moins sujet aux bogues et plus facile à gérer. Les modèles Azure OpenAI peuvent ainsi aider les développeurs à refactoriser leur code.

Observez la fonction suivante.

def calculateTotalPrice(item, quantity):
    if item == 'apple':
        return quantity * 0.5
    elif item == 'banana':
        return quantity * 0.75
    elif item == 'orange':
        return quantity * 0.6
    else:
        return 0

public double CalculateTotalPrice(string item, int quantity)
{
    if (item == "apple")
    {
        return quantity * 0.5;
    }
    else if (item == "banana")
    {
        return quantity * 0.75;
    }
    else if (item == "orange")
    {
        return quantity * 0.6;
    }
    else
    {
        return 0;
    }
}

Ce code calcule le prix total d’un élément particulier en fonction de son nom et de sa quantité. Néanmoins, le code n’est pas modulaire et peut s’avérer difficile à gérer. Lorsqu’il est fourni au modèle avec une demande de refactorisation, voici la réponse obtenue :

item_prices = {  
    'apple': 0.5,  
    'banana': 0.75,  
    'orange': 0.6  
}  

def calculate_total_price(item, quantity):  
    price = item_prices.get(item, 0)  
    return quantity * price  

static Dictionary<string, double> itemPrices = new Dictionary<string, double>()  
{  
    {"apple", 0.5},  
    {"banana", 0.75},  
    {"orange", 0.6}  
};  

static double CalculateTotalPrice(string item, int quantity)  
{  
    double price;  
    if (!itemPrices.TryGetValue(item, out price))  
    {  
        price = 0;  
    }  
    return quantity * price;  
}  

De concert avec le code, le modèle fournit une explication de la refactorisation.

In this refactored code, we've created an object called itemPrices that maps item names to their 
prices. We've also simplified the calculateTotalPrice function by using the itemPrices object to look 
up the price of the item, rather than using a series of if/else statements. This makes the code more 
modular and easier to maintain, and also reduces the risk of introducing bugs in the future.