Einführung in Elixir Lang

Eine Einführung in die Programmiersprache Elixir (und warum ich sie liebe)

Ich habe vor ein paar Monaten einen Artikel geschrieben, in dem ich Ihnen Golang vorgestellt habe und warum ich es so sehr geliebt habe. Obwohl ich es tatsächlich immer noch liebe, habe ich in letzter Zeit mit einer neuen Sprache herumgespielt; Elixier. Ich habe mir das Buch Programming Elixir gekauft und es durchgelesen. Ich habe Elixir bereits lieben gelernt und hoffe, Ihnen in diesem Artikel zu zeigen, warum.

Während ich vor ein paar Jahren für Couchbase arbeitete, interessierte ich mich sehr für Erlang und verteilte Systeme. Für mich ist Erlang verwirrend. Als ich Elixir sah, wusste ich sofort, dass ich etwas Gutes vor mir hatte. Elixir wird als funktionale und gleichzeitige Sprache beschrieben, die auf der Erlang-VM ausgeführt wird.

Ich habe oft gehört, dass Leute sagen, Elixir sei 'Ruby for Erlang' usw. Diese Theorie ist nicht ganz falsch, aber realistischerweise ist es hauptsächlich nur die Syntax von Elixir, die von Ruby beeinflusst wird, da sie nicht geteilt wird viele der gleichen Programmierkonstrukte. Es ist natürlich in gewisser Weise ähnlich wie Erlang, da es auf der Erlang-VM aufgebaut ist und uns direkten Zugriff auf die Erlang-Primitive von Haus aus gibt.

Wie auch immer, lass uns ohne weiteres Zögern eintauchen und mit etwas Elixir weitermachen.

Installation

Wenn Sie OSX verwenden, ist die Installation so einfach wie die Verwendung von Homebrew:
~ brew update
~ brew install erlang
~ brew install elixir

Sobald Sie dies getan haben, sollten Sie in der Lage sein, Folgendes auszuführen:

~ elixir -v
> Elixir 1.0.2

Jetzt ist Elixir richtig installiert, wir können ein interaktives Elixir öffnen und mit einigen grundlegenden gängigen Typen herumspielen.

Geben Sie Elixier ein

Starten Sie ein Interactive Elixir REPL durch Eingabe
> iex

Variablen:

iex(1)> name = "rbin"
#=> "rbin"

Atome:

In Elixir ist ein Atom eine Konstante, in der sein Name sein eigener Wert ist.
iex(2)> :this_is_an_atom
#=> :this_is_an_atom
iex(3)> :my_atom == :atom
#=> false

Tupel:

Wir verwenden die Schreibweise der geschweiften Klammern, um Tupel zu definieren. In Elixir werden Tupel sofort im Speicher gespeichert, was bedeutet, dass das Ermitteln der Größe eines Tupels oder der Zugriff auf ein Tupelelement schnell ist, aber das Aktualisieren oder Hinzufügen von Elementen ist teuer, da das gesamte Tupel in den Speicher kopiert werden muss.

iex(4)> tuple = {:hello, "world"}
#=> {:hello, "world"}
iex(5)> elem(tuple, 1)
#=> "world"

Listen:

In Elixir werden Listen als verknüpfte Listen im Speicher gespeichert. Wir können Listen trivial aktualisieren, indem wir Elemente voranstellen, aber das Anhängen von Elementen ist teurer, da wir die gesamte Liste durchlaufen müssen, um ihre Größe zu ermitteln.

iex(8)> list = [1, 2, :atom]
#=> [1, 2, :atom]
iex(9)> ["string"] ++ list
#=> ["string", 1, 2, :atom]
iex(10)> list ++ [31]
#=> [1, 2, :atom, 31]

Es gibt sehr nützliche eingebaute Funktionen, die mit Listen verwendet werden können, einschließlich des Abrufens von Head & Tail einer Liste.

iex(11)> hd(list)
#=> 1
iex(12)> tl(list)
#=> [2, :atom]

Anonyme Funktionen:

In Elixir sind Funktionen erstklassige Bürger, was bedeutet, dass wir Funktionen als Argumente an andere Funktionen übergeben können. Unten definieren wir eine Variable namens add , die eine Funktion enthält, die wir dann als Argument an is_function/1 func übergeben.

iex(14)> add = fn a, b -> a + b end
#Function<12.90072148/2 in :erl_eval.expr/5>

iex(15)> add.(13, 31)
#=> 44

iex(16)> is_function(add)
#=> true

Organisation unserer Projekte (Mix)

Elixir wird mit einem super nützlichen Tool namens Mix geliefert. Mix ist ein Build-Tool, mit dem wir unsere Projekte sehr einfach generieren, organisieren, kompilieren und testen können. Es macht es uns auch leicht, Abhängigkeiten zu verwalten. (Immer ein heikles Thema!) Um ein neues Projekt mit Mix zu erstellen, gehen wir einfach wie folgt vor:
~ mix new myapp --module MyApp
Dadurch wird ein Verzeichnis namens myapp mit einigen Dateien darin erstellt. Es wird auch ein Modul MyApp in lib/myapp.ex definieren .
* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/myapp.ex
* creating test
* creating test/test_helper.exs
* creating test/myapp_test.exs

Your mix project was created successfully.
You can use mix to compile it, test it, and more:
cd myapp
mix test
Wie wir sehen können, erhalten wir alle Dateien, die für eine grundlegende Projektstruktur benötigt werden. Ich denke, dies ist eine der netteren Funktionen, die mit Elixir geliefert werden. Projektmanagement-Tools zu haben ist super nützlich und eine große Zeitersparnis.

Die Datei mix.exs ist die Hauptdatei, die verwendet wird, um unser Projekt zu konfigurieren und Abhängigkeiten zu verwalten usw. Wir erhalten einen test/Ordner , in dem wir sehr Ruby-ähnliche Tests für unser Projekt schreiben können. Wir erhalten natürlich einen lib/folder , der die Quelldateien zu unserem Projekt enthält. Wenn wir einen Mix-Test für unsere App ausführen, erhalten wir Folgendes:
$ mix test
Compiled lib/myapp.ex
Generated myapp.app
.
Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
1 tests, 0 failures
Randomized with seed 543313

Parallelität

Ähnlich wie Erlang verwendet Elixir das „Actor“-Modell für Parallelität. Unser gesamter Code wird innerhalb von Processes ausgeführt , und diese Prozesse sind voneinander isoliert. Wir können vollständig gleichzeitige Programme in Elixir erstellen, indem wir Prozesse erzeugen und Nachrichten zwischen ihnen senden und empfangen .

In Elixir starten wir Prozesse mit der Spawn -Funktion, die eine andere Funktion als Argument akzeptiert.

iex(1)> spawn(fn -> IO.puts 1 + 1 end)
#=> 2
#PID<0.55.0>

Wie Sie sehen können, haben wir einen Prozess erzeugt, der 1 + 1 ausgegeben und auch seine Prozess-ID zurückgegeben hat. Die Rückgabe dieser Prozess-ID ist nützlich, da wir sie einer Variablen zuweisen und sie verwenden können, um Nachrichten an den Prozess zu senden. Bevor wir das tun, müssen wir einen Empfangsmechanismus erstellen, um die Nachrichten zu erhalten, die wir an den Prozess senden. (Wir können dies in unserer interaktiven Elixir- Sitzung Zeile für Zeile tun.)

Sobald wir das getan haben, können wir einen Prozess erstellen, der area_loop auswertet, und ihn pid zuweisen.

pid = spawn(fn -> Geometry.area_loop() end)
#=> #PID<0.40.0>

Wir können dann Nachrichten an pid senden, auf die unser vordefinierter Code passt, je nachdem, ob er das :rectangle -Atom oder das :circle -Atom erhält.

send pid, {:rectangle, 2, 3}
#=> Area = 6
# {:rectangle,2,3}

send pid, {:circle, 2}
#=> Area = 12.56000000000000049738
# {:circle,2}

Mit Process.alive? können wir überprüfen, ob Prozesse noch laufen. Funktion.

Process.alive?(pid)
#=> false

Fazit

Wir haben in diesem Blog noch nicht einmal an der Oberfläche gekratzt. Es gibt so viele erstaunliche Funktionen in Elixir, ich hoffe, Sie werden es selbst ausprobieren. Ich habe unten einige Lernressourcen aufgelistet, die Ihnen auf Ihrem Weg helfen sollen, aber bevor Sie sich auf den Weg machen und eintauchen, hier sind einige meiner persönlichen Lieblingssachen über Elixir:

• Es war leicht zu verstehen, mit einer Ruby-ähnlichen Syntax und Erlang-ähnlichen Primitives
• Dahinter steht eine fantastische Community
• Das Nebenläufigkeitsmodell ist mir sowohl vertraut als auch sehr leistungsfähig
• Mix ist ein Glücksfall und spart VIEL Zeit
• Elixir ermutigt uns, alles zu dokumentieren
• Es macht das Erstellen verteilter Apps zu einem viel weniger verwirrenden Schlachtfeld
• Ich kann mir vorstellen, dass Elixir einen LANGEN Weg gehen wird.

Ressourcen

Einige Ressourcen, die ich in meiner kurzen Zeit beim Erlernen von Elixir als sehr nützlich empfunden habe:

• http://elixir-lang.org/getting-started/introduction.html
• https://pragprog.com/book/elixir/programming-elixir
• https://teamgaslight.com/blog/the-best-resources-for-learning-elixir
• http://exerzismus.io

* Geh hinaus und nippe an diesem Elixier! – @rbin *