Granska GitHub Copilot kodkompletteringsfunktioner

  • 8 minuter

GitHub Copilot innehåller två typer av infogade förslag. Förslag på spöktext visas som nedtonad text på den aktuella markörplatsen när du skriver. Nästa redigeringsförslag (NES) förutsäger både platsen och innehållet i din nästa kodredigering baserat på de senaste ändringarna du har gjort.

Du får förslag på spöktext när du utför följande åtgärder:

  • Ange en partiell eller fullständig kodrad i redigeraren.
  • Ange en partiell eller fullständig kodkommentare i redigeraren.
  • Ange en tom kodrad i redigeraren.

Nästa redigeringsförslag visas automatiskt när du redigerar kod. De förutsäger vilken ändring du sannolikt kommer att göra härnäst baserat på dina senaste redigeringar och visas med en särskild indikator som visar den föreslagna redigeringsplatsen.

Vanliga scenarier för nästa redigeringsförslag

Nästa redigeringsförslag är särskilt användbara i tre kodningsscenarier:

  • Fånga misstag: NES identifierar problem som stavfel (conts x = 5 → const x = 5), inverterade ternary-uttryck och felaktiga jämförelseoperatorer och föreslår sedan rätt korrigering.
  • Sammanhängande avsiktsändringar: När du byter namn på en typ eller variabel föreslår NES spridning genom all beroende kod. Om du till exempel byter namn på en klass från Point till Point3D utlöses förslag på att lägga till en z koordinat där koden behöver den.
  • Refaktorisering: När du har bytt namn på en variabel en gång föreslår NES att alla andra förekomster uppdateras. Efter att ha klistrat in kod föreslår NES att den anpassas så att den matchar stilen i den omgivande koden.

Generera ett förslag på spöktext

GitHub Copilot påskyndar apputvecklingen genom att föreslå kodslutningar baserat på koden du skriver.

Anta till exempel att du vill skapa en C#-metod med namnet addInt som returnerar summan av två heltal. Om du börjar skriva metodsignaturen föreslår GitHub Copilot koden som du tror att du vill skapa.

Skärmbild av Visual Studio Code-redigeraren som visar ett förslag på spöktext för metoden addInt body.

Förslag på spöktext visas utan färgad syntaxmarkering. Detta hjälper till att skilja förslaget från din befintliga kod. Du kan acceptera den föreslagna koden genom att trycka på tabbtangenten.

Du kan trycka på Esc-tangenten för att stänga ett förslag.

Exemplet addInt är lite förenklat, så du kanske undrar hur GitHub Copilot gör med något mer komplext.

Anta att du vill skapa en metod som accepterar en lista med tal och returnerar summan av de primära talen i listan. Du kan ge metoden namnet addPrimeNumbersInNumericList. När du börjar skriva metodsignaturen genererar GitHub Copilot ett förslag åt dig. Till exempel:

Skärmbild av Visual Studio Code-redigeraren som visar ett förslag på spöktext för metoden addPrimeNumbersInNumericList.

Det är viktigt att granska förslag innan du godkänner dem. Det här spöktextförslaget ser bra ut, så du kan acceptera förslaget genom att trycka på tabbtangenten.

Låt oss fortsätta scenariot lite längre.

När förslaget har sammanfogats i koden ser du att isPrime metoden är understruken i rött. Det beror på att isPrime metoden inte finns i koden än.

GitHub Copilot är tränad att följa bästa praxis, bland annat genom att dela upp komplexa problem i mindre, mer hanterbara delar. I det här fallet föreslår GitHub Copilot att du skapar en separat isPrime-metod för att kontrollera om ett tal är primärt.

GitHub Copilot är redo att föreslå ett kodfragment för metoden isPrime. När du anger en tom rad under metoden addPrimeNumbersInNumericList föreslår GitHub Copilot en metod isPrime som du kan använda.

Skärmbild av Visual Studio Code redigeraren som visar ett spöktextförslag för isPrime-hjälpmetoden som visas efter metoden addPrimeNumbersInNumericList.

Förslag på spöktext påskyndar utvecklingsprocessen genom att tillhandahålla kodfragment. Men vad händer om förslagen inte är riktigt vad du behöver? GitHub Copilot tillhandahåller ett gränssnitt för att hantera förslag på spöktext.

Hantera förslag på spöktext

När GitHub Copilot föreslår att en spöktext ska slutföras tillhandahåller den också ett gränssnitt för att hantera förslagen. Du kan acceptera ett förslag, granska andra förslag eller avvisa förslagen.

När du hovra muspekaren över en föreslagen automatisk komplettering visas flera alternativ för att hantera förslagen.

Skärmbild av Visual Studio Code-redigeraren som visar verktygsfältet för hantering av spöktextförslag med alternativ för att Acceptera, Acceptera ord, navigering och ytterligare alternativ.

Standardgränssnittet för att hantera förslag innehåller följande alternativ:

  • Acceptera förslaget (i sin helhet) genom att välja Acceptera. Du kan också acceptera förslaget genom att trycka på tabbtangenten.
  • Acceptera förslaget delvis genom att välja Accept Word. Du kan också delvis acceptera ett förslag genom att trycka på tangenterna Ctrl + → (högerpil).
  • Visa alternativa förslag genom att välja > eller <. Du kan också visa de alternativa förslagen genom att trycka på tangenterna Alt + ] eller Alt + [.

Om du väljer alternativet Accept Word godkänns nästa word i ett förslag. Detta är användbart när du vill acceptera en del av förslaget och sedan fortsätta skriva din egen kod. Du kan till exempel acceptera det första ordet i metodförslaget isPrime .

Fortsätt att välja Accept Word tills du har accepterat så mycket av förslaget som du vill.

Om du väljer ellipsikonen (...) till höger om knappen Acceptera Word finns ytterligare alternativ, till exempel Accept Line och Always Show Toolbar.

Om du väljer alternativet Visa verktygsfältet alltid ser du till att verktygsfältet förblir synligt när du använder kortkommandon för att hantera förslag på spöktext. Om du väljer alternativet Öppna kompletteringar öppnas panelen GitHub Copilot Kompletteringar.

Anmärkning

Om du vill acceptera en hel rad i ett förslag måste du konfigurera en anpassad kortkommando för editor.action.inlineSuggest.acceptNextLine kommandot. Det här alternativet är inte tillgängligt som standard i verktygsfältet.

Generera kodförslag från kommentarer

Förutom att föreslå en automatisk komplettering baserat på kod kan GitHub Copilot använda kodkommentarer för att föreslå kodfragment. Använd fraser på naturligt språk för att beskriva den kod som du vill skapa. På så sätt kan GitHub Copilot föreslå förslag för automatisk komplettering som uppfyller specifika krav. Du kan till exempel ange vilken typ av algoritm som du vill använda i en beräkning, eller vilka metoder och egenskaper som du vill lägga till i en klass.

Nu går vi tillbaka till exemplet med primtal. Nu har du följande kod:

int addPrimeNumbersInNumericList(List<int> numbers)
{
    int sum = 0;
    foreach (int number in numbers)
    {
        if (IsPrime(number))
        {
            sum += number;
        }
    }
    return sum;
}

private bool IsPrime(int number)
{
    if (number <= 1)
    {
        return false;
    }
    for (int i = 2; i <= Math.Sqrt(number); i++)
    {
        if (number % i == 0) return false;
    }
    return true;
}

Metoderna addPrimeNumbersInNumericList och isPrime verkar vara fullständiga. Du behöver dock fortfarande en lista med tal som kan användas som argument när du anropar addPrimeNumbersInNumericList metoden. Du kan skriva en kommentar som beskriver listan med tal som du vill ha. Till exempel en lista med 100 slumpmässiga tal som sträcker sig från 1 och 1 000.

När du börjar ange kommentaren föreslår GitHub Copilot en automatisk komplettering som slutför kommentaren åt dig. GitHub Copilot använder din omgivande kod för att förbättra dess förslag. Om du till exempel börjar ange kommentaren // create använder GitHub Copilot den omgivande koden för att förutsäga vad du vill skapa. I det här fallet använder GitHub Copilot metoden addPrimeNumbersInNumericList för att förutsäga att du vill skapa a list of numbers.

Skärmbild av Visual Studio Code-redigeraren som visar ett förslag på spöktext som slutför en kommentar för att

När du fortsätter att skriva kommentaren uppdaterar GitHub Copilot dess förslag för automatisk komplettering. När du är redo att acceptera förslaget väljer du Acceptera eller trycker på tabbtangenten.

När du skapar en ny kodrad efter kommentaren börjar GitHub Copilot generera ett kodfragment baserat på kommentaren och din befintliga kod.

Skärmbild av Visual Studio Code redigeraren som visar ett förslag på spöktext för den första kodraden baserat på kommentaren ovan.

Acceptera vart och ett av förslagen som de visas. Om GitHub Copilot inte är klar genererar det ett annat förslag som du kan acceptera.

Om du anger en ny kodrad när kodfragmentet har slutförts genererar GitHub Copilot ytterligare ett förslag för automatisk komplettering baserat på kraven i kodprojektet.

Sammanfattning

Ghost-textförslag och nästa redigeringsförslag hjälper dig att skriva kod mer effektivt och korrekt. Förslag på spöktext visas som nedtonad text på markörens plats när du skriver. Nästa redigeringsförslag förutsäger platsen och innehållet i din nästa redigering baserat på de senaste ändringarna. Du kan generera ett förslag på spöktext genom att ange en partiell eller fullständig kodrad, en partiell eller fullständig kodkommentar eller en tom kodrad. Du kan acceptera ett förslag genom att trycka på tabbtangenten eller stänga det genom att trycka på Esc-tangenten. Du kan hantera förslag med hjälp av verktygsfältet som visas när du hovrar över ett förslag. Med verktygsfältet kan du granska alternativa förslag, acceptera ett förslag, acceptera ett ord i ett förslag eller öppna panelen GitHub Copilot Completions för att visa fler förslag.