Funktionen erkunden

  • 4 Minuten

Manchmal stellen Sie fest, dass Ihr Code sich ständig wiederholt. Er erfüllt die gleiche Funktion an verschiedenen Stellen, oder es gibt nur geringfügige Unterschiede. In solchen Situationen sollten Sie erwägen, Ihren Code wiederverwendbar zu gestalten. Diese Situation können Sie bewältigen, indem Sie diese Ausdrücke extrahieren und eine oder mehrere Funktionen erstellen. Eine Funktion ist ein Grundbaustein in zahlreichen Programmiersprachen, und F# ist da keine Ausnahme.

Eine Funktion

Eine Funktion ist ein benannter Verweis, deren Text aus einem oder mehreren Ausdrücken besteht. Auch Parameter können vorhanden sein. Eine Funktion beginnt mit dem Schlüsselwort let und dem Namen der Funktion. Dann gibt es einen Zuweisungsoperator, und rechts neben diesem Operator befindet sich der Funktionstext.

Hier sehen Sie die Syntax einer Funktion:

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

Hier sehen Sie ein echtes Beispiel für eine Funktion, bei dem die Syntax aus dem vorherigen Beispiel verwendet wird:

let add a b = a + b

In diesem Beispiel lautet der Name der Funktion add, und die Parameter sind a und b. Der Funktionstext fügt die beiden Parameter a+b zusammen und gibt am Ende das Ergebnis zurück.

Rückgabewerte

Wie Sie im ersten Beispiel gesehen haben, gab es kein Schlüsselwort return, um anzugeben, was zurückgegeben wird. In F# wird stets die Information zurückgegeben, die in der letzten Zeile einer Funktion steht. Betrachten Sie diese mehrzeilige Funktion:

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

Indem product in der letzten Zeile platziert wird, wird angezeigt, welcher Wert zurückgegeben wird. Wie kann eine solche Funktion nun aufgerufen werden?

Aufrufen einer Funktion

Zum Aufrufen einer Funktion verwenden Sie den Namen der Funktion und fügen alle Parameter hinzu, die Sie verwenden möchten. Diese werden durch ein Leerzeichen getrennt. Geben Sie beispielsweise den folgenden Code ein, um die Funktion addAndMultiply() aufzurufen:

addAndMultiply 2 3 3 // 15

Zum Anzeigen der Ergebnisse der Funktion können Sie sie entweder einer Variablen zuweisen oder sie direkt ausgeben:

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

Hergeleitete Typen

Gehen wir von folgendem Code aus:

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

Dieser Code schlägt in der letzten Zeile fehl mit der folgenden Meldung:

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

Der Grund für den Fehler ist, dass F# bereits bestimmt hat, welcher Parametertyp verwendet werden soll: ein Integer. Die Entscheidung für einen Integer wurde aufgrund der Information in der zweiten Zeile getroffen, let sum = add 2 2. Die Funktion add() wurde auf eine Weise verwendet, die darauf hindeutet, dass es sich beim Parametertyp definitiv um Integer handelt.

Wenn die zweite Zeile nicht existierte, würde Ihr Code funktionieren.

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

Der Compiler erkennt, dass die erste Verwendung der Funktion mit Zeichenfolgen erfolgt, und schließt daraus, dass der Parametertyp „string“ lautet. Der Typ wird durch Kontext und erste Verwendung bestimmt.

Explizite Typen

Es gibt Situationen, in denen Sie deutlich festlegen möchten, sowohl welche Parametertypen Sie verwenden als auch was die Funktion zurückgibt. Spezifische Angaben verbessern die Lesbarkeit, auch wenn der Compiler sie wahrscheinlich nicht benötigt.

Sehen Sie sich zum Beispiel die folgende Funktion an:

let convert a =
    int a

Wenn Sie ihm Typen hinzufügen möchten, fügen Sie :<type> hinzu:

let convert (a:string) =
    int a

Der Parameter weist jetzt aufgrund des Codes string den Typ let convert (a:string) auf. Sie können jetzt noch expliziter werden, indem Sie einen Rückgabetyp hinzufügen. Fügen Sie dazu direkt nach Ihrem Parameter ein weiteres :<type> hinzu.

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

Nun wird der Parameter von Klammern eingeschlossen, so wie in (a:string) dargestellt. Der Rückgabetyp entspricht der letzten :<type>-Anmerkung, in diesem Fall :int. F# kann die meisten Szenarios selbst bewältigen, doch manchmal müssen Sie den Code expliziter gestalten. Das Hinzufügen der Typen hat darüber hinaus auch den Vorteil, dass andere Entwickler Ihren Code besser verstehen.