F # - Funktionen

In F # funktionieren Funktionen wie Datentypen. Sie können eine Funktion wie jede andere Variable deklarieren und verwenden.

Da Funktionen wie alle anderen Variablen verwendet werden können, können Sie -

Erstellen Sie eine Funktion mit einem Namen und ordnen Sie diesen Namen einem Typ zu.
Weisen Sie ihm einen Wert zu.
Führen Sie eine Berechnung für diesen Wert durch.
Übergeben Sie es als Parameter an eine andere Funktion oder Unterroutine.
Gibt eine Funktion als Ergebnis einer anderen Funktion zurück.

Funktion definieren

Funktionen werden mit dem definiert letStichwort. Eine Funktionsdefinition hat die folgende Syntax:

let [inline] function-name parameter-list [ : return-type ]
   = function-body

Wo,

function-name ist eine Kennung, die die Funktion darstellt.
parameter-listgibt die Liste der durch Leerzeichen getrennten Parameter an. Sie können auch einen expliziten Typ für jeden Parameter angeben. Wenn dieser nicht angegeben ist, leitet der Compiler ihn tendenziell aus dem Funktionskörper ab (wie Variablen).
function-bodybesteht aus einem Ausdruck oder einem zusammengesetzten Ausdruck, der aus mehreren Ausdrücken besteht. Der letzte Ausdruck im Funktionskörper ist der Rückgabewert.
return-typeist ein Doppelpunkt gefolgt von einem Typ und optional. Wenn der Rückgabetyp nicht angegeben ist, ermittelt der Compiler ihn aus dem endgültigen Ausdruck im Funktionskörper.

Parameter einer Funktion

Sie listen die Namen der Parameter direkt nach dem Funktionsnamen auf. Sie können den Typ eines Parameters angeben. Der Typ des Parameters sollte dem Namen des Parameters folgen, der durch einen Doppelpunkt getrennt ist.

Wenn kein Parametertyp angegeben ist, wird er vom Compiler abgeleitet.

Zum Beispiel -

let doubleIt (x : int) = 2 * x

Eine Funktion aufrufen

Eine Funktion wird aufgerufen, indem der Funktionsname gefolgt von einem Leerzeichen und anschließend durch Leerzeichen getrennte Argumente angegeben werden.

Zum Beispiel -

let vol = cylinderVolume 3.0 5.0

Die folgenden Programme veranschaulichen die Konzepte.

Beispiel 1

Das folgende Programm berechnet das Volumen eines Zylinders, wenn Radius und Länge als Parameter angegeben werden

// the function calculates the volume of
// a cylinder with radius and length as parameters

let cylinderVolume radius length : float =

   // function body
   let pi = 3.14159
   length * pi * radius * radius

let vol = cylinderVolume 3.0 5.0
printfn " Volume: %g " vol

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Volume: 141.372

Beispiel 2

Das folgende Programm gibt den größeren Wert von zwei angegebenen Parametern zurück -

// the function returns the larger value between two
// arguments

let max num1 num2 : int32 =
   // function body
   if(num1>num2)then
      num1
   else
      num2

let res = max 39 52
printfn " Max Value: %d " res

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Max Value: 52

Beispiel 3

let doubleIt (x : int) = 2 * x
printfn "Double 19: %d" ( doubleIt(19))

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Double 19: 38

Rekursive Funktionen

Rekursive Funktionen sind Funktionen, die sich selbst aufrufen.

Sie definieren eine rekursive mit dem let rec Schlüsselwortkombination.

Die Syntax zum Definieren einer rekursiven Funktion lautet -

//Recursive function definition
let rec function-name parameter-list = recursive-function-body

Zum Beispiel -

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)

Beispiel 1

Das folgende Programm gibt Fibonacci 1 bis 10 zurück -

let rec fib n = if n < 2 then 1 else fib (n - 1) + fib (n - 2)
for i = 1 to 10 do
   printfn "Fibonacci %d: %d" i (fib i)

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Fibonacci 1: 1
Fibonacci 2: 2
Fibonacci 3: 3
Fibonacci 4: 5
Fibonacci 5: 8
Fibonacci 6: 13
Fibonacci 7: 21
Fibonacci 8: 34
Fibonacci 9: 55
Fibonacci 10: 89

Beispiel 2

Das folgende Programm gibt Fakultät 8 zurück -

open System
let rec fact x =
   if x < 1 then 1
   else x * fact (x - 1)
Console.WriteLine(fact 8)

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Pfeilnotationen in F #

F # meldet den Datentyp in Funktionen und Werten unter Verwendung einer verketteten Pfeilnotation. Nehmen wir ein Beispiel für eine Funktion, die eine int- Eingabe akzeptiert und eine Zeichenfolge zurückgibt. In Pfeilnotation wird geschrieben als -

int -> string

Datentypen werden von links nach rechts gelesen.

Nehmen wir eine andere hypothetische Funktion, die zwei int-Dateneingaben verwendet und eine Zeichenfolge zurückgibt.

let mydivfunction x y = (x / y).ToString();;

F # meldet den Datentyp unter Verwendung der verketteten Pfeilnotation als -

val mydivfunction : x:int -> y:int -> string

Der Rückgabetyp wird durch den Datentyp ganz rechts in der verketteten Pfeilnotation dargestellt.

Einige weitere Beispiele -

Notation	Bedeutung
float → float → float	Die Funktion verwendet zwei Float- Eingaben und gibt einen weiteren Float zurück .
int → string → float	Die Funktion nimmt eine int- und eine string- Eingabe entgegen und gibt einen float zurück .

Lambda-Ausdrücke

EIN lambda expression ist eine unbenannte Funktion.

Nehmen wir ein Beispiel für zwei Funktionen -

let applyFunction ( f: int -> int -> int) x y = f x y
let mul x y = x * y
let res = applyFunction mul 5 7
printfn "%d" res

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Wenn wir im obigen Beispiel anstelle der Definition der Funktion mul Lambda-Ausdrücke als - hätten verwenden können

let applyFunction ( f: int -> int -> int) x y = f x y
let res = applyFunction (fun x y -> x * y ) 5 7
printfn "%d" res

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

Funktionszusammensetzung und Pipelining

In F # kann eine Funktion aus anderen Funktionen zusammengesetzt werden.

Das folgende Beispiel zeigt die Zusammensetzung einer Funktion mit dem Namen f aus zwei Funktionen function1 und function2 -

let function1 x = x + 1
let function2 x = x * 5

let f = function1 >> function2
let res = f 10
printfn "%d" res

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben:

F # bietet auch eine Funktion namens pipelining of functions. Durch Pipelining können Funktionsaufrufe als aufeinanderfolgende Operationen miteinander verkettet werden.

Das folgende Beispiel zeigt, dass -

let function1 x = x + 1
let function2 x = x * 5

let res = 10 |> function1 |> function2
printfn "%d" res

Wenn Sie das Programm kompilieren und ausführen, wird die folgende Ausgabe ausgegeben: