Elixir Language
Listen

Syntax

• []
• [1, 2, 3, 4]
• [1, 2] ++ [3, 4] # -> [1,2,3,4]
• hd ([1, 2, 3, 4]) # -> 1
• tl ([1, 2, 3, 4]) # -> [2,3,4]
• [Kopf | Schwanz]
• [1 | [2, 3, 4]] # -> [1,2,3,4]
• [1 | [2 | [3 | [4 | []]]]] -> [1,2,3,4]
• 'Hallo' = [? h,? e,? l,? l,? o]
• keyword_list = [a: 123, b: 456, c: 789]
• Schlüsselwortliste [: a] # -> 123

Keyword-Listen

Schlüsselwortlisten sind Listen, bei denen jedes Element in der Liste ein Tupel eines Atoms ist, gefolgt von einem Wert.

keyword_list = [{:a, 123}, {:b, 456}, {:c, 789}]

Eine Kurzschreibweise zum Schreiben von Schlüsselwortlisten lautet wie folgt:

keyword_list = [a: 123, b: 456, c: 789]

Schlüsselwortlisten sind zum Erstellen von geordneten Datenpaaren mit Schlüsselwertpaaren nützlich, in denen mehrere Elemente für einen bestimmten Schlüssel vorhanden sein können.

Das erste Element in einer Keyword-Liste für einen bestimmten Schlüssel kann wie folgt abgerufen werden:

iex> keyword_list[:b]
456

Ein Anwendungsfall für Keyword-Listen kann eine Folge von benannten Aufgaben sein, die ausgeführt werden sollen:

defmodule TaskRunner do
  def run_tasks(tasks) do
    # Call a function for each item in the keyword list.
    # Use pattern matching on each {:key, value} tuple in the keyword list
    Enum.each(tasks, fn
      {:delete, x} ->
        IO.puts("Deleting record " <> to_string(x) <> "...")
      {:add, value} ->
        IO.puts("Adding record \"" <> value <> "\"...")
      {:update, {x, value}} ->
        IO.puts("Setting record " <> to_string(x) <> " to \"" <> value <> "\"...")
    end)
  end
end

Dieser Code kann mit einer Keyword-Liste aufgerufen werden:

iex> tasks = [
...>   add: "foo",
...>   add: "bar",
...>   add: "test",
...>   delete: 2,
...>   update: {1, "asdf"}
...> ]

iex> TaskRunner.run_tasks(tasks)
Adding record "foo"...
Adding record "bar"...
Adding record "test"...
Deleting record 2...
Setting record 1 to "asdf"...

Char-Listen

Zeichenketten in Elixir sind "binaries". Im Erlang-Code sind Zeichenfolgen jedoch traditionell "Zeichenlisten". Wenn Sie Erlang-Funktionen aufrufen, müssen Sie möglicherweise Zeichenlisten anstelle von regulären Elixir-Zeichenfolgen verwenden.

Während regelmäßige Strings geschrieben werden mit doppelten Anführungszeichen " werden char - Listen mit einfachen Anführungszeichen geschrieben ' :

string = "Hello!"
char_list = 'Hello!'

Zeichenlisten sind einfach Listen von ganzen Zahlen, die die Codepunkte jedes Zeichens darstellen.

'hello' = [104, 101, 108, 108, 111]

Eine Zeichenfolge kann mit to_charlist/1 in eine Char-Liste to_charlist/1 :

iex> to_charlist("hello")
'hello'

Und umgekehrt kann mit to_string/1 :

iex> to_string('hello')
"hello"

Aufrufen einer Erlang-Funktion und Konvertieren der Ausgabe in eine reguläre Elixir-Zeichenfolge:

iex> :os.getenv |> hd |> to_string
"PATH=/usr/local/bin:/usr/bin:/bin"

Cons Cells

Listen in Elixir sind verknüpfte Listen. Dies bedeutet, dass jedes Element in einer Liste aus einem Wert besteht, gefolgt von einem Zeiger auf das nächste Element in der Liste. Dies wird in Elixir unter Verwendung von cons-Zellen implementiert.

Cons-Zellen sind einfache Datenstrukturen mit einem "linken" und einem "rechten" Wert oder einem "Kopf" und einem "Schwanz".

A | Ein Symbol kann vor dem letzten Eintrag in einer Liste hinzugefügt werden, um eine (unangemessene) Liste mit einem bestimmten Kopf und einem bestimmten Ende zu notieren. Das Folgende ist eine einzelne Cons-Zelle mit 1 als Kopf und 2 als Schwanz:

[1 | 2]

Die Standardsyntax von Elixir für eine Liste entspricht tatsächlich dem Schreiben einer Kette verschachtelter Konsumzellen:

[1, 2, 3, 4] = [1 | [2 | [3 | [4 | []]]]]

Die leere Liste [] wird als Ende einer Cons-Zelle verwendet, um das Ende einer Liste darzustellen.

Alle Listen in Elixir entsprechen der Form [head | tail] , wobei head der erste Eintrag der Liste ist und tail der Rest der Liste, abzüglich des Heads.

iex> [head | tail] = [1, 2, 3, 4]
[1, 2, 3, 4]
iex> head
1
iex> tail
[2, 3, 4]

Verwendung des [head | tail] -Notation ist nützlich für die Mustererkennung in rekursiven Funktionen:

def sum([]), do: 0

def sum([head | tail]) do
  head + sum(tail)
end

Zuordnungslisten

map ist eine Funktion in der Funktionsprogrammierung, die bei einer Liste und einer Funktion eine neue Liste mit der auf jedes Element dieser Liste angewendeten Funktion zurückgibt. In Elixir befindet sich die map/2 Funktion im Enum- Modul.

iex> Enum.map([1, 2, 3, 4], fn(x) -> x + 1 end)
[2, 3, 4, 5]

Verwenden der alternativen Erfassungssyntax für anonyme Funktionen:

iex> Enum.map([1, 2, 3, 4], &(&1 + 1))
[2, 3, 4, 5]

Verweis auf eine Funktion mit Erfassungssyntax:

iex> Enum.map([1, 2, 3, 4], &to_string/1)
["1", "2", "3", "4"]

Verkettungslistenoperationen mit dem Pipe-Operator:

iex> [1, 2, 3, 4]
...> |> Enum.map(&to_string/1)
...> |> Enum.map(&("Chapter " <> &1))
["Chapter 1", "Chapter 2", "Chapter 3", "Chapter 4"]

Listenverständnisse

Elixir hat keine Schleifen. Anstatt sie für Listen gibt es große Enum und List Module, aber es gibt auch Listenkomprehension.

Listenkomplexe können nützlich sein für:

• Neue Listen erstellen

iex(1)> for value <- [1, 2, 3], do: value + 1
[2, 3, 4] 

• Filtern von Listen mit guard Ausdrücken, aber Sie verwenden sie ohne das Schlüsselwort when .

iex(2)> odd? = fn x -> rem(x, 2) == 1 end
iex(3)> for value <- [1, 2, 3], odd?.(value), do: value
[1, 3]

• Erstellen von benutzerdefinierten Karte, mit into Stichworten:

iex(4)> for value <- [1, 2, 3], into: %{}, do: {value, value + 1}
%{1 => 2, 2=>3, 3 => 4}

Kombiniertes Beispiel

iex(5)> for value <- [1, 2, 3], odd?.(value), into: %{}, do: {value, value * value}
%{1 => 1, 3 => 9}

Zusammenfassung

Listenverständnisse:

• verwendet for..do Syntax mit zusätzlichen Guards nach Kommas und into Keyword, wenn andere Strukturen als Listen zurückgegeben werden, z. Karte.
• In anderen Fällen werden neue Listen zurückgegeben
• unterstützt keine akkus
• Die Verarbeitung kann nicht abgebrochen werden, wenn eine bestimmte Bedingung erfüllt ist
• guard Aussagen sein müssen zuerst , um nach for und vor do oder into Symbolen. Die Reihenfolge der Symbole spielt keine Rolle

Entsprechend diesen Einschränkungen sind List Comprehensions nur für die einfache Verwendung begrenzt. In fortgeschrittenen Fällen wäre die Verwendung von Funktionen aus den Modulen Enum und List die beste Idee.

Unterschied auflisten

iex> [1, 2, 3] -- [1, 3]
[2]

-- entfernt das erste Vorkommen eines Elements in der linken Liste für jedes Element auf der rechten Seite.

Mitgliedschaft auflisten

Verwenden Sie in Operator, um zu prüfen, ob ein Element Mitglied einer Liste ist.

iex> 2 in [1, 2, 3]
true
iex> "bob" in [1, 2, 3]
false

Konvertieren von Listen in eine Karte

Verwenden Sie Enum.chunk/2 , um Elemente in Unterlisten zu gruppieren, und Map.new/2 , um es in eine Map zu konvertieren:

[1, 2, 3, 4, 5, 6]
|> Enum.chunk(2)
|> Map.new(fn [k, v] -> {k, v} end)

Würde geben:

%{1 => 2, 3 => 4, 5 => 6}