Függvények felfedezése
Általában olyan helyzetben találja magát, amikor a kód ismétlődőnek tűnik. Sok helyen ugyanezt teszi, vagy csak kisebb különbségek vannak. Az ilyen helyzetekben gondolja át, hogyan teheti a kód újrafelhasználhatóvá. A helyzet kezelésére úgy lehet megoldást találni, ha kinyeri ezeket a kifejezéseket, és egy vagy több függvényt hoz létre. A függvények számos programozási nyelv alapvető építőeleme, és az F# nem különbözik.
Egy függvény
A függvény egy nevesített hivatkozás egy egy vagy több kifejezésből álló törzstel. Paraméterekkel is rendelkezhet. A függvény a kulcsszóval let és a függvény nevével kezdődik. Ezután van egy hozzárendelési operátor, az operátortól jobbra pedig a függvény törzse.
Egy függvény szintaxisa:
let <function name> <parameters> = <function body>
Az előző példaszintaxisban látható tényleges függvények a következőképpen néznek ki:
let add a b = a + b
Ebben a példában a függvény neve, add a paraméterek a pedig és b. A függvény törzse összeadja a két paramétert, a+bés visszaadja az eredményt.
Visszaadott értékek
Ahogy az első példában is láthatta, nincs return olyan kulcsszó, amely a visszaadott szöveget megadhatja. Az F#-ban a függvény utolsó sorában található információk a visszaadott adatok. Vegye figyelembe ezt a többsoros függvényt:
let addAndMultiply a b c =
let sum = a + b
let product = sum * c
product
Az utolsó sorra helyezéssel product jelzi, hogy mit ad vissza. Szóval, hogyan hívsz meg egy ilyen függvényt?
Függvény meghívása
Függvény meghívásához vagy meghívásához használja a függvény nevét, és adja hozzá a használni kívánt paramétereket szóköz karakterrel elválasztva. A függvény meghívásához addAndMultiply() például írja be a következő kódot:
addAndMultiply 2 3 3 // 15
A függvény eredményeinek megtekintéséhez hozzárendelheti egy változóhoz, vagy kinyomtathatja közvetlenül a következőhöz hasonlóan:
let sum = addAndMultiply 2 3 3
printfn "%i" sum
// OR
printfn "%i" (addAndMultiply 2 3 3)
Elhalasztott típusok
Vegyük a következő kódot:
let add a b = a + b
let sum = add 2 2
let concat = add "hello" "world" // will give compilation error
Ez a kód az utolsó sorban meghiúsul a következő üzenettel:
error FS0001: This expression was expected to have type
'int'
but here has type
'string'
A hiba oka az, hogy az F# már meghatározta, hogy milyen paramétertípust kell használni, és az egész szám mellett döntött. Az egész szám mellett azért döntött, mert a második sorban lévő információ, let sum = add 2 2a . A függvényt add() olyan módon használták, amely azt állította, hogy a paraméter típusa egyértelműen egész szám.
Ha a második sor nem létezik, a kód működik:
let add a b = a + b
// let sum = add 2 2
let concat = add "hello" "world" // will work
A fordító látja, hogy a függvény első használata sztringekkel történik, és arra a következtetésre jut, hogy a paraméter típusa sztring. Tehát a környezet és az első használat a típusra következtet.
Explicit típusok
Vannak olyan helyzetek, amikor explicitnek szeretne lenni, mind arról, hogy milyen típusú paramétereket kell használnia, és hogy a függvény mit ad vissza. Segít a konkrét olvashatóságban, annak ellenére, hogy a fordítónak valószínűleg nincs rá szüksége.
Vegyük például a következő függvényt:
let convert a =
int a
Ha típusokat szeretne hozzáadni hozzá, adja hozzá :<type>a következőhöz hasonlót:
let convert (a:string) =
int a
A paraméter most már a kódon stringkeresztül adja meg a típustlet convert (a:string). Mostantól még explicitebb lehet egy visszatérési típus hozzáadásával. Ehhez adjon hozzá egy másikat :<type> közvetlenül a paraméter után:
let convert (a:string) :int =
int a
Most zárójelek csatolják a paramétert, ahogy az a .(a:string) A visszatérési típus az utolsó :<type> megjegyzés, amely a :intkövetkező: . Az F# elég okos ahhoz, hogy kitalálja a legtöbb forgatókönyvet, de néha explicitebb módon kell segítenie a kódon. A típusok hozzáadásának egy másik előnye, hogy megkönnyíti egy másik fejlesztő számára, hogy megtudja, mi történik.