mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-21 06:11:51 +03:00
2071148e1e
YAML frontmatter had a line that looks like it was mis-patched (started with a `+`). Removed the `+` so the translation is displayed in the right place.
420 lines
12 KiB
Markdown
420 lines
12 KiB
Markdown
---
|
|
language: elixir
|
|
contributors:
|
|
- ["Joao Marques", "http://github.com/mrshankly"]
|
|
translators:
|
|
- ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]
|
|
filename: learnelixir-de.ex
|
|
lang: de-de
|
|
---
|
|
|
|
Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll
|
|
kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt
|
|
viele Features mit.
|
|
|
|
```ruby
|
|
|
|
# Einzeilige Kommentare werden mit der Raute gesetzt.
|
|
|
|
# Es gibt keine mehrzeiligen Kommentare;
|
|
# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander
|
|
# zu setzen (so wie hier).
|
|
|
|
# Mit 'iex' ruft man die Elixir-Shell auf.
|
|
# Zum kompilieren von Modulen dient der Befehl 'elixirc'.
|
|
|
|
# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt
|
|
# installiert wurde.
|
|
|
|
## ---------------------------
|
|
## -- Basistypen
|
|
## ---------------------------
|
|
|
|
# Es gibt Nummern:
|
|
3 # Integer
|
|
0x1F # Integer
|
|
3.0 # Float
|
|
|
|
# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem
|
|
# ':'.
|
|
:hello # Atom
|
|
|
|
# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.
|
|
{1,2,3} # Tupel
|
|
|
|
# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen
|
|
# werden:
|
|
elem({1, 2, 3}, 0) # => 1
|
|
|
|
# Listen sind als verkettete Listen implementiert.
|
|
[1, 2, 3] # list
|
|
|
|
# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:
|
|
[ kopf | rest ] = [1,2,3]
|
|
kopf # => 1
|
|
rest # => [2, 3]
|
|
|
|
# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'
|
|
# (Musterabgleich) und keine Zuweisung.
|
|
# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.
|
|
# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen
|
|
# werden.
|
|
|
|
# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht
|
|
# zusammenpassen.
|
|
# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an
|
|
# Elementen:
|
|
{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
|
|
|
|
# Es gibt außerdem 'binaries',
|
|
<<1,2,3>> # binary.
|
|
|
|
# Strings und 'char lists'
|
|
"hello" # String
|
|
'hello' # Char-Liste
|
|
|
|
# ... und mehrzeilige Strings
|
|
"""
|
|
Ich bin ein
|
|
mehrzeiliger String.
|
|
"""
|
|
#=> "Ich bin ein\nmehrzeiliger String.\n"
|
|
|
|
# Alles Strings werden in UTF-8 enkodiert:
|
|
"héllò" #=> "héllò"
|
|
|
|
# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach
|
|
# Listen.
|
|
<<?a, ?b, ?c>> #=> "abc"
|
|
[?a, ?b, ?c] #=> 'abc'
|
|
|
|
# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.
|
|
?a #=> 97
|
|
|
|
# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'
|
|
[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
|
|
'hello ' ++ 'world' #=> 'hello world'
|
|
|
|
<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
|
|
"hello " <> "world" #=> "hello world"
|
|
|
|
## ---------------------------
|
|
## -- Operatoren
|
|
## ---------------------------
|
|
|
|
# Einfache Arithmetik
|
|
1 + 1 #=> 2
|
|
10 - 5 #=> 5
|
|
5 * 2 #=> 10
|
|
10 / 2 #=> 5.0
|
|
|
|
# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.
|
|
|
|
# Für Division mit ganzzahligen Ergebnis gibt es 'div'
|
|
div(10, 2) #=> 5
|
|
|
|
# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'
|
|
rem(10, 3) #=> 1
|
|
|
|
# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese
|
|
# Operatoren erwarten einen Boolean als erstes Argument.
|
|
true and true #=> true
|
|
false or true #=> true
|
|
# 1 and true #=> ** (ArgumentError) argument error
|
|
|
|
# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs
|
|
# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.
|
|
1 || true #=> 1
|
|
false && 1 #=> false
|
|
nil && 20 #=> nil
|
|
|
|
!true #=> false
|
|
|
|
# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,
|
|
# `<` und `>`
|
|
1 == 1 #=> true
|
|
1 != 1 #=> false
|
|
1 < 2 #=> true
|
|
|
|
# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:
|
|
1 == 1.0 #=> true
|
|
1 === 1.0 #=> false
|
|
|
|
# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:
|
|
1 < :hello #=> true
|
|
|
|
# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:
|
|
# number < atom < reference < functions < port < pid < tuple < list < bitstring
|
|
|
|
# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a
|
|
# total ordering is well defined is important."
|
|
|
|
## ---------------------------
|
|
## -- Kontrollstrukturen
|
|
## ---------------------------
|
|
|
|
# Es gibt die `if`-Verzweigung
|
|
if false do
|
|
"Dies wird nie jemand sehen..."
|
|
else
|
|
"...aber dies!"
|
|
end
|
|
|
|
# ...und ebenso `unless`
|
|
unless true do
|
|
"Dies wird nie jemand sehen..."
|
|
else
|
|
"...aber dies!"
|
|
end
|
|
|
|
# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir
|
|
# arbeiten damit.
|
|
|
|
# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.
|
|
case {:one, :two} do
|
|
{:four, :five} ->
|
|
"Das wird nicht passen"
|
|
{:one, x} ->
|
|
"Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."
|
|
_ ->
|
|
"Dieser Fall greift immer."
|
|
end
|
|
|
|
# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert
|
|
# nicht weiter verwendet wird.
|
|
# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:
|
|
[kopf | _] = [1,2,3]
|
|
kopf #=> 1
|
|
|
|
# Für bessere Lesbarkeit können wir auch das Folgende machen:
|
|
[kopf | _rest] = [:a, :b, :c]
|
|
kopf #=> :a
|
|
|
|
# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man
|
|
# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.
|
|
cond do
|
|
1 + 1 == 3 ->
|
|
"Ich werde nie aufgerufen."
|
|
2 * 5 == 12 ->
|
|
"Ich auch nicht."
|
|
1 + 2 == 3 ->
|
|
"Aber ich!"
|
|
end
|
|
|
|
# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert.
|
|
cond do
|
|
1 + 1 == 3 ->
|
|
"Ich werde nie aufgerufen."
|
|
2 * 5 == 12 ->
|
|
"Ich auch nicht."
|
|
true ->
|
|
"Aber ich! (dies ist im Grunde ein 'else')"
|
|
end
|
|
|
|
# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.
|
|
# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,
|
|
# egal ob zuvor ein Wert gefangen wurde.
|
|
try do
|
|
throw(:hello)
|
|
catch
|
|
nachricht -> "#{nachricht} gefangen."
|
|
after
|
|
IO.puts("Ich bin die 'after'-Klausel.")
|
|
end
|
|
#=> Ich bin die 'after'-Klausel.
|
|
# ":hello gefangen"
|
|
|
|
## ---------------------------
|
|
## -- Module und Funktionen
|
|
## ---------------------------
|
|
|
|
# Anonyme Funktionen (man beachte den Punkt)
|
|
square = fn(x) -> x * x end
|
|
square.(5) #=> 25
|
|
|
|
# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben
|
|
# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'
|
|
# eingeführt:
|
|
f = fn
|
|
x, y when x > 0 -> x + y
|
|
x, y -> x * y
|
|
end
|
|
|
|
f.(1, 3) #=> 4
|
|
f.(-1, 3) #=> -3
|
|
|
|
# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen
|
|
# Geltungsbereich ('scope') verfügbar.
|
|
is_number(10) #=> true
|
|
is_list("hello") #=> false
|
|
elem({1,2,3}, 0) #=> 1
|
|
|
|
# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines
|
|
# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu
|
|
# definieren.
|
|
defmodule Math do
|
|
def sum(a, b) do
|
|
a + b
|
|
end
|
|
|
|
def square(x) do
|
|
x * x
|
|
end
|
|
end
|
|
|
|
Math.sum(1, 2) #=> 3
|
|
Math.square(3) #=> 9
|
|
|
|
# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'
|
|
# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen
|
|
# werden: elixirc math.ex
|
|
|
|
# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine
|
|
# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen
|
|
# werden; eine private Funktion kann nur lokal angesprochen werden.
|
|
defmodule PrivateMath do
|
|
def sum(a, b) do
|
|
do_sum(a, b)
|
|
end
|
|
|
|
defp do_sum(a, b) do
|
|
a + b
|
|
end
|
|
end
|
|
|
|
PrivateMath.sum(1, 2) #=> 3
|
|
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
|
|
|
|
# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:
|
|
defmodule Geometry do
|
|
def area({:rectangle, w, h}) do
|
|
w * h
|
|
end
|
|
|
|
def area({:circle, r}) when is_number(r) do
|
|
3.14 * r * r
|
|
end
|
|
end
|
|
|
|
Geometry.area({:rectangle, 2, 3}) #=> 6
|
|
Geometry.area({:circle, 3}) #=> 28.25999999999999801048
|
|
# Geometry.area({:circle, "not_a_number"})
|
|
#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
|
|
|
|
# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger
|
|
# Bestandteil von Elixir.
|
|
defmodule Recursion do
|
|
def sum_list([head | tail], acc) do
|
|
sum_list(tail, acc + head)
|
|
end
|
|
|
|
def sum_list([], acc) do
|
|
acc
|
|
end
|
|
end
|
|
|
|
Recursion.sum_list([1,2,3], 0) #=> 6
|
|
|
|
# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso
|
|
# ist es möglich eigene Attribute hinzuzufügen.
|
|
defmodule MyMod do
|
|
@moduledoc """
|
|
Dies ist ein eingebautes Attribut in einem Beispiel-Modul
|
|
"""
|
|
|
|
@my_data 100 # Dies ist ein selbst-definiertes Attribut.
|
|
IO.inspect(@my_data) #=> 100
|
|
end
|
|
|
|
## ---------------------------
|
|
## -- 'Records' und Ausnahmebehandlung
|
|
## ---------------------------
|
|
|
|
# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen
|
|
# Namen zuzuweisen.
|
|
defrecord Person, name: nil, age: 0, height: 0
|
|
|
|
joe_info = Person.new(name: "Joe", age: 30, height: 180)
|
|
#=> Person[name: "Joe", age: 30, height: 180]
|
|
|
|
# Zugriff auf den Wert von 'name'
|
|
joe_info.name #=> "Joe"
|
|
|
|
# Den Wert von 'age' überschreiben
|
|
joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
|
|
|
|
# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,
|
|
# um Ausnahmen beziehungsweise Fehler zu behandeln.
|
|
try do
|
|
raise "Irgendein Fehler."
|
|
rescue
|
|
RuntimeError -> "Laufzeit-Fehler gefangen."
|
|
_error -> "Und dies fängt jeden Fehler."
|
|
end
|
|
|
|
# Alle Ausnahmen haben das Attribut 'message'
|
|
try do
|
|
raise "ein Fehler"
|
|
rescue
|
|
x in [RuntimeError] ->
|
|
x.message
|
|
end
|
|
|
|
## ---------------------------
|
|
## -- Nebenläufigkeit
|
|
## ---------------------------
|
|
|
|
# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles
|
|
# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei
|
|
# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen.
|
|
|
|
# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die
|
|
# wiederum eine Funktion als Argument entgegen nimmt.
|
|
f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
|
|
spawn(f) #=> #PID<0.40.0>
|
|
|
|
# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann
|
|
# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um
|
|
# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir
|
|
# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem
|
|
# 'receive'-Mechanismus sichergestellt:
|
|
defmodule Geometry do
|
|
def area_loop do
|
|
receive do
|
|
{:rectangle, w, h} ->
|
|
IO.puts("Area = #{w * h}")
|
|
area_loop()
|
|
{:circle, r} ->
|
|
IO.puts("Area = #{3.14 * r * r}")
|
|
area_loop()
|
|
end
|
|
end
|
|
end
|
|
|
|
# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion
|
|
# in der Shell mit, etwa so:
|
|
pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
|
|
|
|
# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck
|
|
# erfüllt:
|
|
pid <- {:rectangle, 2, 3}
|
|
#=> Area = 6
|
|
# {:rectangle,2,3}
|
|
|
|
pid <- {:circle, 2}
|
|
#=> Area = 12.56000000000000049738
|
|
# {:circle,2}
|
|
|
|
# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man
|
|
# die aktuelle pid herausfinden.
|
|
self() #=> #PID<0.27.0>
|
|
|
|
```
|
|
|
|
## Referenzen und weitere Lektüre
|
|
|
|
* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)
|
|
* [Elixir Documentation](http://elixir-lang.org/docs/master/)
|
|
* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert
|
|
* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong
|