Lasagne

Grundlagen

Variablen

Elixir ist eine dynamisch typisierte Sprache. Das bedeutet, dass der Typ einer Variablen erst zur Laufzeit geprüft wird. Mit dem Match-Operator = binden wir einen Wert beliebigen Typs an einen Variablennamen:

# Bound an integer value of 1
count = 1
# You may re-bind variables
count = 2

# You may re-bind any type to a variable
count = false

# Strings can be created by enclosing characters within double quotes
message = "Success!"

Module

Elixir ist eine funktionale Programmiersprache und verlangt, dass alle benannten Funktionen in einem Modul definiert werden. Mit dem Schlüsselwort defmodule definierst du ein Modul. Alle Module sind zur Laufzeit für alle anderen Module verfügbar und brauchen keinen Zugriffsmodifikator, damit andere Teile des Programms sie sehen können. Ein Modul entspricht einer Klasse in anderen Programmiersprachen.

defmodule Calculator do
  # ...
end

Benannte Funktionen

Benannte Funktionen müssen in einem Modul definiert werden. Mit dem Schlüsselwort def definierst du eine öffentliche benannte Funktion.

Jede Funktion kann null oder mehr Parameter haben. Der Wert des letzten Ausdrucks in einer Funktion wird immer implizit zurückgegeben.

defmodule Calculator do
  def add(x, y) do
    x + y
  end
end

Du rufst eine Funktion auf, indem du ihren Modul- und Funktionsnamen angibst und für jeden Parameter der Funktion ein Argument übergibst.

sum = Calculator.add(1, 2)
# => 3

Mit dem Schlüsselwort defp kannst du statt def eine private Funktion definieren. Private Funktionen kannst du nur innerhalb des Moduls verwenden, das sie definiert hat.

Wenn du eine Funktion innerhalb desselben Moduls aufrufst, in dem sie definiert ist, kannst du den Modulnamen weglassen.

Du kannst kurze Funktionen auch in einer einzeiligen Syntax schreiben (beachte das Komma , und den Doppelpunkt : um das Schlüsselwort do).

defmodule Calculator do
  def subtract(x, y) do
    private_subtract(x, y)
  end

  defp private_subtract(x, y), do: x - y
end

difference = Calculator.subtract(7, 2)
# => 5

difference = Calculator.private_subtract(7, 2)
# => ** (UndefinedFunctionError) function Calculator.private_subtract/2 is undefined or private
#       Calculator.private_subtract(7, 2)

Die Arity von Funktionen

Es ist üblich, Funktionen über ihre Arity anzugeben. Die Arity einer Funktion ist die Anzahl der Argumente, die sie entgegennimmt.

# add/3 because this function has three arguments, thus an arity of 3
def add(x, y, z) do
  x + y + z
end

Namenskonventionen

Modulnamen solltest du in PascalCase schreiben. Ein Modulname muss mit einem Großbuchstaben A-Z beginnen und darf Buchstaben a-zA-Z, Zahlen 0-9 und Unterstriche _ enthalten.

Variablen- und Funktionsnamen solltest du in snake_case schreiben. Ein Variablen- oder Funktionsname muss mit einem Kleinbuchstaben a-z oder einem Unterstrich _ beginnen, darf Buchstaben a-zA-Z, Zahlen 0-9 und Unterstriche _ enthalten und kann mit einem Fragezeichen ? oder einem Ausrufezeichen ! enden.

Standardbibliothek

Elixir hat eine sehr umfangreiche und gut dokumentierte Standardbibliothek. Die Dokumentation findest du online unter hexdocs.pm/elixir. Speichere diesen Link irgendwo, du wirst ihn oft brauchen!

Zu den meisten eingebauten Datentypen gibt es ein passendes Modul mit Funktionen für diesen Datentyp. So gibt es das Modul Integer für Ganzzahlen, das Modul String für Strings, das Modul List für Listen und so weiter.

Ein bemerkenswertes Modul ist das Modul Kernel. Es stellt die grundlegenden Fähigkeiten bereit, auf denen der Rest der Standardbibliothek aufbaut, etwa arithmetische Operatoren, Makros für den Kontrollfluss und vieles mehr. Die Funktionen des Moduls Kernel werden automatisch importiert, du kannst sie also ohne das Präfix Kernel. verwenden.

Kommentare im Code

Mit Kommentaren kannst du Notizen für andere Entwickler hinterlassen, die den Quellcode lesen. Einzeilige Kommentare in Elixir beginnen mit #.