Einführung
Arrays
Die Cairo-Kernbibliothek implementiert einen Array-Typ.
Er ähnelt den üblichen Array-Typen anderer Programmiersprachen, weist aber ein paar wichtige Unterschiede auf:
- Elemente können effizient nur hinten an den
Array-Typ angehängt werden, und effizient entfernen lassen sie sich nur vorne.
- Es ist nicht möglich, ein Element über den Array-Index manuell zu setzen.
Arrays lassen sich mit der Funktion ArrayTrait::new und auch mit dem array!-Makro erstellen:
let empty: Array<u32> = ArrayTrait::new();
let one_to_four = array![1, 2, 3, 4];
Elemente lassen sich mit der Funktion ArrayTrait::append zum Array hinzufügen:
let mut num_array = array![1, 2, 3, 4];
num_array.append(5);
// -> [1, 2, 3, 4, 5]
Elemente lassen sich mit der Funktion ArrayTrait::pop_front aus dem Array entfernen:
let mut one_to_four = array![1, 2, 3, 4];
one_to_four.pop_front();
// -> [2, 3, 4]
Cairo führt außerdem einen Span-Typ ein, der wie eine „Momentaufnahme“ des Array funktioniert.
Jeder Array kann mit der Funktion ToSpanTrait::span in einen Span umgewandelt werden:
let one_to_four = array![1, 2, 3, 4];
let one_to_four_span = one_to_four.span();
// -> [1, 2, 3, 4]
Ein Array in einen Span umzuwandeln ist sehr effizient, denn Span ist nur eine Datenstruktur, die es Cairo erlaubt, einen Abschnitt des Arrays zu „betrachten“, ohne ihn in irgendeiner Weise zu verändern.
Indem Cairo ein Array in einen Span umwandelt, erlaubt es mehr Operationen, als direkt auf Array möglich wären, zum Beispiel das Entfernen eines Elements vom Anfang des Span.
let one_to_four = array![1, 2, 3, 4];
let mut one_to_four_span = one_to_four.span();
one_to_four_span.pop_back();
// -> [2, 3, 4]
Beachte, dass wir one_to_four_span mit dem Schlüsselwort mut veränderlich machen mussten, um pop_back aufzurufen. Dieser Aufruf verändert den Span, indem er den Abschnitt des Arrays verkürzt, den der Span gerade „betrachtet“.
Anleitung
Als angehende Magierin muss Elyse einige Grundlagen üben.
Sie hat einen Stapel Karten, den sie bearbeiten möchte.
Um es etwas einfacher zu machen, verwendet sie nur die Karten 1 bis 10.
Der Kartenstapel wird durch ein Array dargestellt, wobei sich das untere Ende des Stapels vorne im Array und das obere Ende hinten befindet.
1. Füge eine Karte oben auf den Stapel ein
Implementiere die Funktion insert_top, die eine Kopie des Stapels zurückgibt, wobei die angegebene neue Karte oben auf den Stapel gelegt wird.
let stack = array![5, 9, 7, 1];
insert_top(stack, 8);
// -> [5, 9, 7, 1, 8]
2. Entferne die oberste Karte vom Stapel
Implementiere die Funktion remove_top_card, die eine Kopie des Stapels zurückgibt, bei der die oberste Karte entfernt wurde.
Wenn der angegebene Stapel leer ist, soll der ursprüngliche Stapel unverändert zurückgegeben werden.
let stack = array![3, 2, 6, 4, 8];
remove_top_card(stack);
// -> [3, 2, 6, 4]
3. Füge eine Karte unten in den Stapel ein
Implementiere die Funktion insert_bottom, die eine Kopie des Stapels zurückgibt, wobei die angegebene neue Karte unten in den Stapel gelegt wird.
let stack = array![5, 9, 7, 1];
insert_bottom(stack, 8);
// -> [8, 5, 9, 7, 1]
4. Entferne eine Karte vom unteren Ende des Stapels
Implementiere die Funktion remove_bottom_card, die eine Kopie des Stapels zurückgibt, bei der die unterste Karte entfernt wurde.
Wenn der angegebene Stapel leer ist, soll der ursprüngliche Stapel unverändert zurückgegeben werden.
let stack = array![8, 5, 9, 7, 1];
remove_bottom_card(stack);
// -> [5, 9, 7, 1]
5. Überprüfe die Größe des Stapels
Implementiere die Funktion check_size_of_stack, die überprüft, ob die Größe des Stapels gleich dem angegebenen stack_size ist oder nicht.
let stack = array![3, 2, 6, 4, 8];
check_size_of_stack(stack, 4);
// -> false
Um zu verstehen, warum die Arbeit mit Arrays in Cairo nicht so unkompliziert ist wie in anderen Programmiersprachen, hilft es, sich vor Augen zu halten, dass Cairo ein unveränderliches Speichermodell verwendet. Das bedeutet: Sobald eine Speicherzelle beschrieben wurde, kann sie nie überschrieben, sondern nur gelesen werden.
Die Sprache abstrahiert dieses Merkmal ein wenig weg und erlaubt es Entwicklern, ihre Variablen zu deklarieren und zu verwenden, als wären sie veränderbar.
Auch wenn das das Schreiben von Code etwas anspruchsvoller macht, besonders von Code, der den Typ Array verwendet (einschließlich ByteArray, das unter der Haube ein „Array aus Bytes“ ist), ermöglicht es das Schreiben beweisbarer Programme, die man bedenkenlos auch auf nicht vertrauenswürdigen Maschinen ausführen kann. Damit ist der Kompromiss mehr als wettgemacht.
Lernübung
