Åtgärda buggar och förbättra koden

  • 7 minuter

Utvecklare kan ibland skriva kod som främst fungerar, men kan förbättras genom att åtgärda buggar, syntax, prestanda eller modularitet. Azure OpenAI-modeller kan hjälpa dig att identifiera sätt att förbättra och ge förslag på hur du skriver bättre kod.

Åtgärda buggar i koden

Azure OpenAI-modeller kan hjälpa dig att åtgärda buggar i kod genom att analysera koden och föreslå ändringar som potentiellt kan åtgärda problemet. Detta kan hjälpa utvecklare att identifiera och lösa buggar snabbare och effektivare.

Anta till exempel att du har följande funktion som inte fungerar åt dig.

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

Ange den funktionen till modellen, tillsammans med uppmaningen Fix the bugs in this function, och du får ett svar med den fasta koden och en förklaring av vad som har åtgärdats.

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.

Bättre prestanda

Även om kodutvecklare skriver kan det fungera, men det kan finnas ett effektivare sätt att utföra uppgiften. Här är ett exempel på en funktion som beräknar summan av de första n positiva heltalen, eventuellt ineffektivt:

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

Den här versionen fungerar korrekt, men dess tidskomplexitet är O(n). Här är svaret när den tillhandahålls till modellen:

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

Den här versionen returnerar fortfarande rätt resultat, men dess tidskomplexitet är nu O(1), vilket gör den mycket mer effektiv.

Ineffektiv kod för omstrukturerare

Bättre kod är mindre känslig för buggar och är enklare att underhålla, och Azure OpenAI-modellerna kan hjälpa utvecklare att omstrukturera sin kod.

Överväg följande funktion.

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

Den här koden beräknar det totala priset för ett visst objekt baserat på dess namn och kvantitet. Koden är dock inte modulär och kan vara svår att underhålla. Här är svaret när den tillhandahålls till modellen med begäran om att omstrukturera den:

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

Tillsammans med koden ger modellen en förklaring av refaktorindelningen.

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.