Do you want to pick up from where you left of?
Take me there

Ausführbare Dateien

Um ausführbare Dateien in Elixir zu erstellen werden wir escript benutzen. Escript erzeugt eine ausführbare Datei, welche auf jedem System lauffähig ist, auf dem Erlang installiert ist.

Table of Contents

Einstieg

Um eine ausführbare Datei mit escript zu erzeugen gibt es nur wenige Dinge zu tun: Eine main/1 Methode erzeugen und das Mixfile anpassen.

Wir starten mit der Erzeugung eines Moduls, welches als Einstiegspunkt für unsere ausführbare Datei dienen soll. Dort werden wir main/1 implementieren:

defmodule ExampleApp.CLI do
  def main(args \\ []) do
    # Mache irgendetwas
  end
end

Als nächstes müssen wir für unser Projekt in unserem Mixfile die :escript Option aufnehmen. Dazu müssen wir noch ein :main_module festlegen:

defmodule ExampleApp.Mixproject do
  def project do
    [app: :example_app, version: "0.0.1", escript: escript()]
  end

  defp escript do
    [main_module: ExampleApp.CLI]
  end
end

Argumente parsen

Mit unserer erstellten Anwendung können wir dazu übergehen Kommandozeilenargumente zu parsen. Um das zu tun werden wir Elixirs OptionParser.parse/2 mit der :switches Option nutzen, um darauf hinzuweisen, dass unser flag boolean ist:

defmodule ExampleApp.CLI do
  def main(args \\ []) do
    args
    |> parse_args
    |> response
    |> IO.puts()
  end

  defp parse_args(args) do
    {opts, word, _} =
      args
      |> OptionParser.parse(switches: [upcase: :boolean])

    {opts, List.to_string(word)}
  end

  defp response({opts, word}) do
    if opts[:upcase], do: String.upcase(word), else: word
  end
end

Erstellen

Sobald wir die Konfiguration unserer Anwendung mit escript abgeschlossen haben ist die Erzeugung einer ausführbaren Datei mit der Hilfe von Mix einfach:

mix escript.build

Let’s take it for a spin:

$ ./example_app --upcase Hello
HELLO

$ ./example_app Hi
Hi

Das wars. Wir haben unsere erste ausführbare Datei in Elixir mit escript erzeugt.

Caught a mistake or want to contribute to the lesson? Edit this lesson on GitHub!
Previous Lesson

Fehlerbehandlung

Obwohl es üblich ist das {:error, reason}-Tupel zurückzugeben, unterstützt Elixir Exceptions und in dieser Lektion werden wir lernen, wie man Fehler behandelt und welche verschiedenen Möglichkeiten wir haben.

Üblicherweise ist die Konvention in Elixir eine Funktion (example/1) zu schreiben, welche {:ok, result} oder {:error, reason} zurückgibt und eine separate Funktion (example!/1), die das “rohe” result zurückgibt oder einen Fehler wirft.

Diese Lektion wird sich auf den zweiten Fall konzentrieren

Next Lesson

Nebenläufigkeit

Einer der wichtigsten Gründe für den Einsatz von Elixir ist die eingebaute Unterstützung von Nebenläufigkeit. Dank der Erlang VM (BEAM) ist Nebenläufigkeit in Elixir einfacher als erwartet. Die Nebenläufigkeit basiert auf dem Actor Model, bei dem ein abgeschlossener Prozess mit anderen Prozessen durch message passing kommuniziert.

In dieser Lektion werden wir uns die Nebenläufigkeitsmodule anschauen, welche mit Elixir geliefert werden Im darauf folgenden Kapitel werden wir OTP behandeln, die diese Module implementieren.