Ulme - Funktionen

Funktionen sind die Bausteine eines Elm-Programms. Eine Funktion ist eine Reihe von Anweisungen zum Ausführen einer bestimmten Aufgabe.

Funktionen organisieren das Programm in logischen Codeblöcken. Einmal definiert, können Funktionen aufgerufen werden, um auf Code zuzugreifen. Dies macht den Code wiederverwendbar. Darüber hinaus erleichtern Funktionen das Lesen und Verwalten des Programmcodes.

Schritte zur Verwendung einer Funktion

Die Verwendung einer Funktion erfolgt in drei Schritten:

Funktionserklärung

Eine Funktionsdeklaration informiert den Compiler über den Namen, den Rückgabetyp und die Parameter einer Funktion. Die Syntax zum Deklarieren einer Funktion ist unten angegeben -

fn_name:data_type_of_the_parameters ->return_type

Die Funktionsdeklaration gibt Folgendes an:

Name der Funktion.
Datentyp der Parameter. Dies ist optional, da eine Funktion Parameter haben kann oder nicht.
Datentyp des Werts, den die Funktion zurückgibt. Funktionen in Elm müssen immer einen Wert zurückgeben, da Elm eine funktionale Programmiersprache ist. Im Gegensatz zu Funktionen in anderen Programmiersprachen verwenden Elm-Funktionen das Schlüsselwort return nicht, um einen Wert zurückzugeben.

Funktionsdefinition oder Funktionsimplementierung

Eine Funktionsdefinition liefert den tatsächlichen Hauptteil der Funktion. Eine Funktionsdefinition gibt an, wie eine bestimmte Aufgabe ausgeführt werden soll. Die Syntax zum Definieren einer Funktion lautet wie folgt:

fn_name parameter1 parameter2 = statements

Aufrufen oder Aufrufen einer Funktion

Eine Funktion muss aufgerufen werden, um sie auszuführen. Die Syntax zum Aufrufen einer Funktion ist unten angegeben -

fn_name parameter1 parameter2

Illustration

Der folgende Code definiert eine Funktionsbegrüßung. Die Funktion gibt eine Zeichenfolge "Hallo" zurück.

> greet = \
| if True then \
| "Hello" \
| else \
| "GoodBye"
"Hello" : String
> greet
"Hello" : String

Parametrisierte Funktionen

Parameter sind ein Mechanismus zum Übergeben von Werten an eine Funktion. Die Werte der Parameter werden zum Zeitpunkt des Funktionsaufrufs an die Funktion übergeben.

Abbildung 1

Das folgende Beispiel definiert eine Funktion fn_add . Die Funktion akzeptiert zwei Zahlen als Parameter und gibt deren Summe zurück. Versuchen Sie Folgendes in Ulme REPL -

> fn_add x y = x+y
<function> : number -> number -> number
> fn_add 10 20
30 : number

Abbildung 2

Das folgende Beispiel definiert eine Funktion sayHello. Die Funktion sayHello akzeptiert und gibt einen String-Wert als Parameter zurück und gibt einen String zurück.

> sayHello name = "Hello "++ name
<function> : String -> String
> sayHello "Tutorialspoint"
"Hello Tutorialspoint" : String
>

Rohrbetreiber

Um den Pipe-Operator |> zu verstehen, betrachten wir ein Beispiel, in dem wir eine Liste verschiedener Zeichenfolgen ["a", "b", "c"] haben . Jetzt brauchen wir eine einzelne Zeichenfolge, die durch - getrennt ist.

Das folgende Beispiel zeigt, wie das mit String.join gemacht wird

> String.join "-" ["a","b","c","d","e","f"]
"a-b-c-d-e-f" : String

Dieselbe Aktion kann mit einem Pipe-Operator |> ausgeführt werden. Mit dem Pipe-Operator können mehrere Funktionsaufrufe verkettet werden.

> ["a","b","c","d","e","f"] |> String.join "-"
"a-b-c-d-e-f" : String
> ["a","b","c","d","e","f"] |> List.reverse |> String.join "-"
"f-e-d-c-b-a" : String

Im ersten Beispiel verketten wir die Liste mit der Join-Methode. Im zweiten Fall wird dieselbe Liste an die Umkehrfunktion weitergeleitet und anschließend an die Verbindung weitergeleitet. Die Liste wird also umgekehrt angezeigt und verbunden.