Ulme - Liste

Die Datenstrukturen List, Tuples und Record können zum Speichern einer Sammlung von Werten verwendet werden.

In diesem Kapitel wird die Verwendung von List in Elm erläutert.

Eine Liste ist eine Sammlung homogener Werte. Die Werte in einer Liste müssen alle vom gleichen Datentyp sein.

Beachten Sie die folgenden Einschränkungen, wenn Sie Variablen zum Speichern von Werten verwenden:

Variablen sind skalarer Natur. Mit anderen Worten, zum Zeitpunkt der Deklaration kann eine Variable nur einen Wert enthalten. Dies bedeutet, dass zum Speichern von n Werten in einem Programm n Variablendeklarationen erforderlich sind. Daher ist die Verwendung von Variablen nicht möglich, wenn eine größere Sammlung von Werten gespeichert werden muss.
Variablen in einem Programm wird Speicher in zufälliger Reihenfolge zugewiesen, wodurch es schwierig wird, die Werte in der Reihenfolge ihrer Deklaration abzurufen / zu lesen.

Syntax

List_name = [value1,value2,value3.....valuen]

Illustration

Das folgende Beispiel zeigt, wie eine Liste in Elm verwendet wird. Versuchen Sie dieses Beispiel in Ulme REPL -

> myList1 = [10,20,30]
[10,20,30] : List number
> myList2 = ["hello","world"]
["hello","world"] : List String

Wenn wir versuchen, Werte verschiedener Typen zu einer Liste hinzuzufügen, gibt der Compiler einen Typ-Mismatch-Fehler aus. Dies ist unten gezeigt.

> myList = [1,"hello"]
-- TYPE MISMATCH 
--------------------------------------------- 
repl-temp-000.elm

The 1st and 2nd entries in this list are different types of values.

4| [1,"hello"]
^^^^^^^
The 1st entry has this type:
   number
But the 2nd is:
   String

Operationen auflisten

Die folgende Tabelle zeigt die allgemeinen Operationen in einer Liste -

Sr. Nr	Methode	Beschreibung
1	isEmpty: Liste a -> Bool	prüft, ob die Liste leer ist
2	umgekehrt: Liste a -> Bool	kehrt die Eingabeliste um
3	Länge: Liste a -> Int	Gibt die Größe der Liste zurück
4	Maximum: Liste vergleichbar -> Vielleicht. Vielleicht vergleichbar	Gibt den Maximalwert zurück
5	Minimum: Liste vergleichbar -> Vielleicht. Vielleicht vergleichbar	Gibt den Mindestwert zurück
6	Summe: Listennummer -> Nummer	Gibt die Summe aller Elemente in der Liste zurück
7	Produkt: Listennummer -> Nummer	prüft, ob die Liste leer ist
8	sort: Liste vergleichbar -> Liste vergleichbar	sortiert Liste in aufsteigender Reihenfolge
9	concat: Liste (Liste a) -> Liste a	führt eine Reihe von Listen zu einer zusammen
10	anhängen: Liste a -> Liste a -> Liste a	führt zwei Listen zusammen
11	Bereich: Int -> Int -> Liste Int	Gibt eine Liste mit Zahlen von Anfang bis Ende zurück
12	Filter: (a -> Bool) -> Liste a -> Liste a	Filtert die Werteliste aus der Eingabeliste
13	head: Liste a -> Vielleicht. Vielleicht a	Gibt das erste Element aus der Liste zurück
14	Schwanz :: Liste a -> Vielleicht.Maibe (Liste a)	Gibt alle Elemente außer dem Kopf zurück

ist leer

Diese Funktion gibt true zurück, wenn eine Liste leer ist.

Syntax

List.isEmpty list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.isEmpty
<function> : List a -> Bool

Illustration

> List.isEmpty
<function> : List a -> Bool

> List.isEmpty [10,20,30]
False : Bool

umkehren

Diese Funktion kehrt die Liste um.

Syntax

List.reverse list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.reverse
<function> : List a -> List a

Illustration

> List.reverse [10,20,30]
[30,20,10] : List number

Länge

Diese Funktion gibt die Länge einer Liste zurück.

Syntax

List.length list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.length
<function> : List a -> Int

Illustration

> List.length [10,20,30]
3 : Int

maximal

Diese Funktion gibt das maximale Element in einer nicht leeren Liste zurück.

Syntax

List.maximum list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.maximum
<function> : List comparable -> Maybe.Maybe comparable

Illustration

> List.maximum [10,20,30]
Just 30 : Maybe.Maybe number
> List.maximum []
Nothing : Maybe.Maybe comparable

Minimum

Diese Funktion gibt das minimale Element in einer nicht leeren Liste zurück.

Syntax

List.minimum list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.minimum
<function> : List comparable -> Maybe.Maybe comparable

Illustration

> List.minimum [10,20,30]
Just 10 : Maybe.Maybe number

Summe

Diese Funktion gibt die Summe aller Elemente in einer Liste zurück.

Syntax

List.sum list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.sum
<function> : List number -> number

Illustration

> List.sum [10,20,30]
60 : number

Produkt

Diese Funktion gibt das Produkt aller Elemente in einer Liste zurück.

Syntax

List.product list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

<function>  : List number ->  number

Illustration

List.product [10,20,30]
6000 : number

Sortieren

Diese Funktion sortiert die Werte in einer Liste vom niedrigsten zum höchsten Wert.

Syntax

List.sort list_name

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.sort
<function> : List comparable -> List comparable

Illustration

> List.sort [10,20,30]
[10,20,30] : List number

concat

Diese Funktion verkettet eine Reihe von Listen zu einer einzigen Liste.

Syntax

List.concat [ [list_name1],[list_name2],[list_name3],.....[list_nameN] ]

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.concat
<function> : List (List a) -> List a

Illustration

> List.concat [[10,20], [30,40],[50,60]]
[10,20,30,40,50,60] : List number

anhängen

Diese Funktion fügt zwei Listen zusammen.

Syntax

List.append [list_name1] [list_name2]

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.append
<function> : List a -> List a -> List a

Illustration

> List.append [10,20] [30,40]
[10,20,30,40] : List number

Der ++ - Operator kann auch verwendet werden, um eine Liste an eine andere anzuhängen. Dies wird im folgenden Beispiel gezeigt -

> [10.1,20.2] ++ [30.3,40.4]
[10.1,20.2,30.3,40.4] : List Float

Angebot

Diese Funktion erstellt eine Liste von Zahlen, wobei jedes Element um eins erhöht wird. Die niedrigste und die höchste Zahl, die in der Liste enthalten sein sollte, werden an die Funktion übergeben.

Syntax

List.range start_range end_range

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.range
<function> : Int -> Int -> List Int

Illustration

> List.range 1 10
[1,2,3,4,5,6,7,8,9,10] : List Int

Filter

Diese Funktion filtert eine Reihe von Werten aus der Eingabeliste. Behalten Sie nur die Werte bei, die den Test bestehen.

Syntax

List.filter test_function input_list

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.filter
<function> : (a -> Bool) -> List a -> List a

Illustration

Das folgende Beispiel filtert alle geraden Zahlen aus einer Eingabeliste

> List.filter (\n -> n%2==0) [10,20,30,55]
[10,20,30] : List Int

Kopf

Diese Funktion gibt das erste Element aus der Eingabeliste zurück.

Syntax

List.head input_list

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.head
<function> : List a -> Maybe.Maybe a

Illustration

> List.head [10,20,30,40]
Just 10 : Maybe.Maybe number
> List.head []
Nothing : Maybe.Maybe a

Schwanz

Diese Funktion gibt alle Elemente nach dem ersten in der Liste zurück.

Syntax

List.tail input_list

Um die Signatur der Funktion zu überprüfen, geben Sie Folgendes in elm REPL - ein.

> List.tail
<function> : List a -> Maybe.Maybe (List a)

Illustration

> List.tail [10,20,30,40,50]
Just [20,30,40,50] : Maybe.Maybe (List number)
> List.tail [10]
Just [] : Maybe.Maybe (List number)
> List.tail []
Nothing : Maybe.Maybe (List a)

Verwenden des Cons-Operators

Der Nachteile-Operator (::) fügt ein Element am Anfang einer Liste hinzu.

Illustration

> 10::[20,30,40,50]
[10,20,30,40,50] : List number

Das neu hinzuzufügende Element und der Datentyp der Werte in der Liste müssen übereinstimmen. Der Compiler gibt einen Fehler aus, wenn die Datentypen nicht übereinstimmen.

> [1,2,3,4]::[5,6,7,8]
-- TYPE MISMATCH ---------------------------------
------------ repl-temp-000.elm

The right side of (::) is causing a type mismatch.

3| [1,2,3,4]::[5,6,7,8]
			  ^^^^^^^^^
(::) is expecting the right side to be a:

   List (List number)

But the right side is:

   List number
Hint: With operators like (::) I always check the left side first. If it seems fine, 
I assume it is correct and check the right side. So the 
problem may be in how the left and right arguments interact.

Listen sind unveränderlich

Lassen Sie uns prüfen, ob Listen in Elm unveränderlich sind. Die erste Liste myList erstellt bei Verkettung mit Wert 1 eine neue Liste und wird an myListCopy zurückgegeben . Wenn wir also die Anfangsliste anzeigen, werden ihre Werte nicht geändert.

> myList = [10,20,30]
[10,20,30] : List number
> myListCopy = 1::myList
[1,10,20,30] : List number
> myList
[10,20,30] : List number
>myList == myListCopy
False : Bool