Kom igång med F# i Visual Studio Code

Artikel
03/05/2024

Du kan skriva F# i Visual Studio Code med plugin-programmet Ionide för att få en bra plattformsoberoende, enkel IDE-upplevelse (Integrated Development Environment) med IntelliSense och kodrefaktoriseringar. Besök Ionide.io om du vill veta mer om plugin-programmet.

Börja med att se till att du har F# och Ionide-plugin-programmet korrekt installerat.

Skapa ditt första projekt med Ionide

Om du vill skapa ett nytt F#-projekt öppnar du en kommandorad och skapar ett nytt projekt med .NET CLI:

dotnet new console -lang "F#" -o FirstIonideProject

När det är klart ändrar du katalogen till projektet och öppnar Visual Studio Code:

cd FirstIonideProject
code .

När projektet har lästs in i Visual Studio Code bör du se fönstret F# Solution Explorer till vänster i fönstret öppet. Det innebär att Ionide har läst in projektet som du nyss skapade. Du kan skriva kod i redigeraren före den här tidpunkten, men när detta händer har allt lästs in.

Skriv ditt första skript

När du har konfigurerat Visual Studio Code för att använda .NET Core-skript navigerar du till Utforskarvyn i Visual Studio Code och skapar en ny fil. Ge den namnet MyFirstScript.fsx.

Lägg nu till följande kod i den:

let toPigLatin (word: string) =
    let isVowel (c: char) =
        match c with
        | 'a' | 'e' | 'i' | 'o' | 'u'
        | 'A' | 'E' | 'I' | 'O' | 'U' -> true
        |_ -> false
    
    if isVowel word[0] then
        word + "yay"
    else
        word[1..] + string(word[0]) + "ay"

Den här funktionen konverterar ett ord till en form av Pig Latin. Nästa steg är att utvärdera det med hjälp av F# Interactive (FSI).

Markera hela funktionen (den ska vara 11 rader lång). När den är markerad håller du alt-tangenten och trycker på Retur. Du kommer att märka att ett terminalfönster visas längst ned på skärmen, och det bör se ut ungefär så här:

Example of F# Interactive output with Ionide

Detta gjorde tre saker:

Det startade FSI-processen.
Den skickade koden som du markerade över till FSI-processen.
FSI-processen utvärderade koden som du skickade över.

Eftersom det du skickade över var en funktion kan du nu anropa den funktionen med FSI! I det interaktiva fönstret skriver du följande:

toPigLatin "banana";;

Du bör se följande resultat:

val it: string = "ananabay"

Nu ska vi försöka med en vokal som första bokstav. Ange följande:

toPigLatin "apple";;

Du bör se följande resultat:

val it: string = "appleyay"

Funktionen verkar fungera som förväntat. Grattis, du har precis skrivit din första F#-funktion i Visual Studio Code och utvärderat den med FSI!

Kommentar

Som du kanske har märkt avslutas raderna i FSI med ;;. Det beror på att du kan ange flera rader med FSI. I ;; slutet meddelar FSI när koden är klar.

Förklara koden

Om du inte är säker på vad koden faktiskt gör, här är ett steg för steg.

Som du ser toPigLatin är en funktion som tar ett ord som indata och konverterar det till en pig-latinsk representation av det ordet. Reglerna för detta är följande:

Om det första tecknet i ett ord börjar med en vokal lägger du till "yay" i slutet av ordet. Om det inte börjar med en vokal flyttar du det första tecknet till slutet av ordet och lägger till "ay" i det.

Du kanske har märkt följande i FSI:

val toPigLatin: word: string -> string

Det här anger att toPigLatin är en funktion som tar in som string indata (kallas word) och returnerar en annan string. Detta kallas funktionens typsignatur, en grundläggande del av F# som är nyckeln till att förstå F#-kod. Du kommer också att märka detta om du hovra över funktionen i Visual Studio Code.

I funktionens brödtext ser du två distinkta delar:

En inre funktion med namnet isVowel, som avgör om ett visst tecken (c) är en vokal genom att kontrollera om den matchar något av de angivna mönstren via mönstermatchning:
```
let isVowel (c: char) =
    match c with
    | 'a' | 'e' | 'i' | 'o' | 'u'
    | 'A' | 'E' | 'I' | 'O' | 'U' -> true
    |_ -> false
```
Ett if..then..else uttryck som kontrollerar om det första tecknet är en vokal och konstruerar ett returvärde utifrån indatatecken baserat på om det första tecknet var en vokal eller inte:
```
if isVowel word[0] then
    word + "yay"
else
    word[1..] + string(word[0]) + "ay"
```

Flödet av toPigLatin är således:

Kontrollera om det första tecknet i indataordet är en vokal. I så fall bifogar du "yay" i slutet av ordet. Annars flyttar du det första tecknet till slutet av ordet och lägger till "ay" i det.

Det finns en sista sak att märka om detta: i F# finns det ingen explicit instruktion att återvända från funktionen. Det beror på att F# är uttrycksbaserat och det sista uttrycket som utvärderas i en funktions brödtext avgör funktionens returvärde. Eftersom if..then..else det i sig är ett uttryck avgör utvärderingen av blockets then brödtext eller blockets else brödtext det värde som returneras av toPigLatin funktionen.

Omvandla konsolappen till en Pig Latin-generator

Föregående avsnitt i den här artikeln visade ett vanligt första steg i att skriva F#-kod: skriva en första funktion och köra den interaktivt med FSI. Detta kallas REPL-driven utveckling, där REPL står för "Read-Evaluate-Print Loop". Det är ett bra sätt att experimentera med funktioner tills du har något som fungerar.

Nästa steg i REPL-driven utveckling är att flytta arbetskod till en F#-implementeringsfil. Den kan sedan kompileras av F#-kompilatorn till en sammansättning som kan köras.

Börja genom att öppna filen Program.fs som du skapade tidigare med .NET CLI. Du kommer att märka att viss kod redan finns där.

Skapa sedan en ny module med namnet PigLatin och kopiera den toPigLatin funktion som du skapade tidigare till den som sådan:

module PigLatin =
    let toPigLatin (word: string) =
        let isVowel (c: char) =
            match c with
            | 'a' | 'e' | 'i' | 'o' | 'u'
            | 'A' | 'E' | 'I' | 'O' | 'U' -> true
            |_ -> false
        
        if isVowel word[0] then
            word + "yay"
        else
            word[1..] + string word[0] + "ay"

Den här modulen main bör ligga ovanför funktionen och under deklarationen open System . Ordningen på deklarationer är viktig i F#, så du måste definiera funktionen innan du anropar den i en fil.

main I funktionen anropar du nu funktionen Pig Latin generator på argumenten:

[<EntryPoint>]
let main args =
    for arg in args do
        let newArg = PigLatin.toPigLatin arg
        printfn "%s in Pig Latin is: %s" arg newArg

    0

Nu kan du köra konsolappen från kommandoraden:

dotnet run apple banana

Och du ser att det ger samma resultat som din skriptfil, men den här gången som ett program som körs!

Felsöka Ionide

Här följer några sätt att felsöka vissa problem som du kan stöta på:

För att få kodredigeringsfunktionerna i Ionide måste dina F#-filer sparas på disken och inuti en mapp som är öppen i Visual Studio Code-arbetsytan.
Om du har gjort ändringar i systemet eller installerat Ionide-krav med Visual Studio Code öppet startar du om Visual Studio Code.
Om du har ogiltiga tecken i projektkatalogerna kanske Ionide inte fungerar. Byt namn på dina projektkataloger om så är fallet.
Om inget av Ionide-kommandona fungerar kontrollerar du dina Visual Studio Code-nyckelbindningar för att se om du åsidosättar dem av misstag.
Om Ionide är trasigt på datorn och inget av ovanstående har åtgärdat problemet kan du prova att ta bort ionide-fsharp katalogen på datorn och installera om plugin-paketet.
Om ett projekt inte kunde läsas in (F#Solution Explorer visar detta) högerklickar du på projektet och klickar på Se information för att få mer diagnostikinformation.

Ionide är ett projekt med öppen källkod som skapats och underhålls av medlemmar i F#-communityn. Rapportera problem och delta gärna på GitHub-lagringsplatsen ionide-vscode-fsharp.

Du kan också be om ytterligare hjälp från Ionide-utvecklarna och F#-communityn i Ionide Gitter-kanalen.

Nästa steg

Mer information om F# och språkets funktioner finns i Tour of F#.