Hibák kijavítása és a kód javítása

  • 7 perc

A fejlesztők néha olyan kódot írhatnak, amely többnyire működik, de javíthatók a hibák, a szintaxis, a teljesítmény vagy a modularitás javításával. Az Azure OpenAI-modellek segíthetnek azonosítani a jobb fejlesztési módszereket, és javaslatokat nyújthatnak a jobb kódíráshoz.

Hibajavítás a kódban

Az Azure OpenAI-modellek segíthetnek kijavítani a kód hibáit a kód elemzésével, és olyan módosításokat javasolhatnak, amelyek esetleg megoldhatják a problémát. Ez segíthet a fejlesztőknek a hibák gyorsabb és hatékonyabb azonosításában és megoldásában.

Tegyük fel például, hogy az alábbi függvény nem működik Önnek.

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

Adja meg ezt a függvényt a modellnek a parancssorral Fix the bugs in this functionegyütt, és választ kap a rögzített kóddal és a kijavított hiba magyarázatával.

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.

A teljesítmény javítása

Bár a kódfejlesztők írása működhet, a feladat végrehajtásának hatékonyabb módja is lehet. Íme egy példa egy függvényre, amely kiszámítja az első n pozitív egész számok összegét, esetleg nem hatékony:

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

Ez a verzió megfelelően működik, de az idő összetettsége O(n). Ha a modell meg van adva, a következő választ adja:

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

Ez a verzió továbbra is a megfelelő eredményt adja vissza, de az idő összetettsége most O(1), ami sokkal hatékonyabb.

Nem hatékony kód újrabontása

A jobb kód kevésbé hajlamos a hibákra, és könnyebben karbantartható, és az Azure OpenAI-modellek segíthetnek a fejlesztőknek a kód újrabontásában.

Vegye figyelembe a következő függvényt.

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

Ez a kód egy adott cikk teljes árát számítja ki annak neve és mennyisége alapján. A kód azonban nem moduláris, és nehéz lehet karbantartani. Ha a modellnek meg van adva az újrabontásra vonatkozó kérés, a következő választ adja:

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

A kóddal együtt a modell magyarázatot ad az újrabontásra.

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.