Elixier - Funktionen

Eine Funktion ist eine Reihe von Anweisungen, die zusammen organisiert sind, um eine bestimmte Aufgabe auszuführen. Funktionen in der Programmierung funktionieren meistens wie Funktionen in Mathe. Sie geben Funktionen eine Eingabe, sie generieren eine Ausgabe basierend auf der bereitgestellten Eingabe.

Es gibt 2 Arten von Funktionen in Elixir -

Anonyme Funktion

Mit dem definierte Funktionen fn..end constructsind anonyme Funktionen. Diese Funktionen werden manchmal auch als Lambdas bezeichnet. Sie werden verwendet, indem sie Variablennamen zugewiesen werden.

Benannte Funktion

Mit dem definierte Funktionen def keywordsind benannte Funktionen. Dies sind native Funktionen, die in Elixir bereitgestellt werden.

Anonyme Funktionen

Wie der Name schon sagt, hat eine anonyme Funktion keinen Namen. Diese werden häufig an andere Funktionen übergeben. Um eine anonyme Funktion in Elixir zu definieren, benötigen wir diefn und endSchlüsselwörter. Innerhalb dieser können wir eine beliebige Anzahl von Parametern und Funktionskörpern definieren, die durch getrennt sind->. Zum Beispiel,

sum = fn (a, b) -> a + b end
IO.puts(sum.(1, 5))

Wenn über dem Programm ausgeführt wird, wird das folgende Ergebnis generiert:

6

Beachten Sie, dass diese Funktionen nicht wie die genannten Funktionen aufgerufen werden. Wir haben ein '.'zwischen dem Funktionsnamen und seinen Argumenten.

Verwenden des Capture-Operators

Wir können diese Funktionen auch mit dem Erfassungsoperator definieren. Dies ist eine einfachere Methode zum Erstellen von Funktionen. Wir werden nun die obige Summenfunktion mit dem Erfassungsoperator definieren.

sum = &(&1 + &2) 
IO.puts(sum.(1, 2))

Wenn das obige Programm ausgeführt wird, generiert es das folgende Ergebnis:

3

In der Kurzversion werden unsere Parameter nicht benannt, sondern stehen uns als & 1, & 2, & 3 usw. zur Verfügung.

Pattern Matching-Funktionen

Der Mustervergleich ist nicht nur auf Variablen und Datenstrukturen beschränkt. Wir können Pattern Matching verwenden, um unsere Funktionen polymorph zu machen. Zum Beispiel werden wir eine Funktion deklarieren, die entweder 1 oder 2 Eingaben (innerhalb eines Tupels) annehmen und diese auf der Konsole drucken kann.

handle_result = fn
   {var1} -> IO.puts("#{var1} found in a tuple!")
   {var_2, var_3} -> IO.puts("#{var_2} and #{var_3} found!")
end
handle_result.({"Hey people"})
handle_result.({"Hello", "World"})

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hey people found in a tuple!
Hello and World found!

Benannte Funktionen

Wir können Funktionen mit Namen definieren, damit wir später leicht darauf verweisen können. Benannte Funktionen werden innerhalb eines Moduls mit dem Schlüsselwort def definiert. Benannte Funktionen werden immer in einem Modul definiert. Um benannte Funktionen aufzurufen, müssen wir sie mit ihrem Modulnamen referenzieren.

Das Folgende ist die Syntax für benannte Funktionen -

def function_name(argument_1, argument_2) do
   #code to be executed when function is called
end

Definieren wir nun unsere benannte Funktionssumme im Math-Modul.

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

IO.puts(Math.sum(5, 6))

Wenn das obige Programm ausgeführt wird, wird folgendes Ergebnis erzielt:

11

Für 1-Liner-Funktionen gibt es eine Kurzschreibweise, um diese Funktionen mithilfe von zu definieren do:. Zum Beispiel -

defmodule Math do
   def sum(a, b), do: a + b
end
IO.puts(Math.sum(5, 6))

Wenn das obige Programm ausgeführt wird, wird folgendes Ergebnis erzielt:

11

Private Funktionen

Elixir bietet uns die Möglichkeit, private Funktionen zu definieren, auf die innerhalb des Moduls zugegriffen werden kann, in dem sie definiert sind. Verwenden Sie zum Definieren einer privaten Funktiondefp Anstatt von def. Zum Beispiel,

defmodule Greeter do
   def hello(name), do: phrase <> name
   defp phrase, do: "Hello "
end

Greeter.hello("world")

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello world

Aber wenn wir nur versuchen, die Phrasenfunktion explizit aufzurufen, verwenden Sie die Greeter.phrase() Funktion wird ein Fehler ausgelöst.

Standardargumente

Wenn wir einen Standardwert für ein Argument wünschen, verwenden wir das argument \\ value Syntax -

defmodule Greeter do
   def hello(name, country \\ "en") do
      phrase(country) <> name
   end

   defp phrase("en"), do: "Hello, "
   defp phrase("es"), do: "Hola, "
end

Greeter.hello("Ayush", "en")
Greeter.hello("Ayush")
Greeter.hello("Ayush", "es")

Wenn das obige Programm ausgeführt wird, wird das folgende Ergebnis erzeugt:

Hello, Ayush
Hello, Ayush
Hola, Ayush