Udforsk funktioner

Normalt befinder du dig i en situation, hvor din kode ser gentagen ud. Det gør det samme mange steder, eller der er kun mindre forskelle. I situationer som disse kan du overveje, hvordan du kan genbruge kode. Den måde at håndtere denne situation på er ved at udtrække disse udtryk og gøre en eller flere funktioner. En funktion er en grundlæggende dokumentkomponent på mange programmeringssprog, og F# er ikke anderledes.

En funktion

En funktion er en navngiven reference med en brødtekst, der består af et eller flere udtryk. Den kan også have parametre. En funktion starter med nøgleordet let og navnet på funktionen. Derefter er der en tildelingsoperator, og til højre for denne operator er funktionsbrødteksten.

Her er syntaksen for en funktion:

let <function name> <parameters> = <function body>

Et eksempel på en faktisk funktion, som vist med ovenstående eksempelsyntaks, ser sådan ud:

let add a b = a + b 

I dette eksempel er navnet på funktionen add, og parametrene er a og b. Funktionens brødtekst tilføjer de to parametre sammen, a+b, og returnerer resultatet.

Returner værdier

Som du så i det første eksempel, er der ingen return nøgleord til at angive, hvad der returneres. I F#er oplysningerne på den sidste linje i en funktion det, der returneres. Overvej denne multilinjefunktion:

let addAndMultiply a b c = 
    let sum = a + b
    let product = sum * c
    product

Ved at placere product på den sidste linje fortæller den dig, hvad der returneres. Så hvordan kalder du en funktion som denne?

Kald en funktion

Hvis du vil kalde eller aktivere en funktion, skal du bruge navnet på funktionen og tilføje de parametre, du vil bruge, adskilt af et mellemrumstegn. Hvis du f.eks. vil kalde funktionen addAndMultiply(), skal du angive følgende kode:

addAndMultiply 2 3 3 // 15

Hvis du vil se resultaterne af funktionen, kan du enten tildele den til en variabel eller udskrive den direkte, f.eks.:

let sum = addAndMultiply 2 3 3
printfn "%i" sum
// OR
printfn "%i" (addAndMultiply 2 3 3)

Udledte typer

Lad os tage følgende kode:

let add a b = a + b
let sum = add 2 2 
let concat = add "hello" "world" // will give compilation error

Denne kode mislykkes på den sidste linje med følgende meddelelse:

error FS0001: This expression was expected to have type
    'int'    
but here has type
    'string'    

Årsagen til fejlen er, at F# allerede har bestemt, hvilken parametertype der skal bruges, og den besluttede sig for heltal. Årsagen til, at det besluttede sig for heltal, var på grund af oplysningerne i den anden række, let sum = add 2 2. Funktionen add() blev brugt på en måde, der angav, at parametertypen var heltal.

Hvis den anden række ikke findes, fungerer din kode:

let add a b = a + b
// let sum = add 2 2 
let concat = add "hello" "world" // will work

Compileren kan se, at den første brug af funktionen foretages med strenge og konkluderer, at parametertypen er streng. Så kontekst og første brug udlede typen.

Eksplicitte typer

Der er situationer, hvor du vil være eksplicit, både om, hvilken type parametre der skal tages, og hvad funktionen returnerer. Det hjælper læsbarheden med at være specifik, selvom compileren sandsynligvis ikke har brug for den.

Benyt følgende funktion, f.eks.:

let convert a =
    int a

Hvis du vil føje typer til den, skal du tilføje :<type>på følgende måde:

let convert (a:string) =
    int a

Parameteren har nu typen string via koden let convert (a:string). Du kan nu være endnu mere eksplicit ved at tilføje en returtype. Det gør du ved at tilføje endnu en :<type> lige efter parameteren:

let convert (a:string) :int =
    int a

Nu er parenteser omsluttet af parameteren, som vist i (a:string). Returtypen er den sidste :<type> anmærkning, der skal ske, hvilket er :int. F# er klog nok til at finde ud af de fleste scenarier, men nogle gange har du brug for at hjælpe koden ved at være mere eksplicit. En anden fordel ved at tilføje typer er, at det gør det nemmere for en anden udvikler at finde ud af, hvad der foregår.