Karte

Eine Karte ist ein container type, der key-value pairs enthält, die Mappings von einem value zu einem anderen Wert sind. Die Elemente in einer Karte werden nach der Reihenfolge der Schlüssel-Wert-Paare geordnet, wenn du die Karte erstellst, und du greifst auf die elements in der Karte über die von dir definierten eindeutigen Schlüssel zu.

Beispiel: Wenn du die Anzahl der Treffer eines Wortes festhalten willst, kannst du eine Karte erstellen, die das Wort als Schlüssel und seine Anzahl als Wert enthält.

WordCount : [string]int = map{"apple" => 11, "pear" => 7}

Klicke auf das Bild, um es zu vergrößern.

Wenn du beim Initialisieren einer Karte denselben Schlüssel mehrmals verwendest, speichert die Karte nur den Wert, der zuletzt für diesen Schlüssel angegebenen wurde. Im folgenden Beispiel enthält WordCount nur das Schlüssel-Wert-Paar "apple" => 2. Die Paare "apple" => 0 und "apple" => 1 werden verworfen.

WordCount : [string]int = map{"apple" => 0, "apple" => 1, "apple" => 2}

Unterstützte Schlüsseltypen

Schlüssel-Wert-Paare können von jedem beliebigen Typ sein, solange der Schlüsseltyp comparable ist, da es eine Möglichkeit geben muss, um zu überprüfen, ob für eine Karte bereits ein Schlüssel vorhanden ist.

Folgende Typen können als Schlüssel verwendet werden:

• logic

• int

• float

• char

• String

• enum

• Eine Klasse, wenn sie vergleichbar ist

• Eine option, wenn der Elementtyp vergleichbar ist

• Ein Array, wenn der Elementtyp vergleichbar ist

• Eine Karte, wenn sowohl die Schlüssel- als auch die Werttypen vergleichbar sind

• Ein tuple, wenn alle Elemente des Tupels vergleichbar sind

Kartenlänge

Du kannst die Anzahl der Key-Wert-Paare in einer Map ermitteln, indem du in der Map auf das Feld Länge zugreifst. Zum Beispiel gibt map{"a" => "apple", "b" => "bear", "c" => "candy"}.Length 3 zurück.

Auf Elemente in einer Karte zugreifen

Du kannst auf ein element in einer Karte zugreifen, indem du einen Schlüssel verwendest, Beispiel: WordCount["apple"].

Der Zugriff auf ein Element in einer Karte ist ein failable expression und kann nur in einem failure context verwendet werden, z. B. in einem if expression. Beispiel:

ExampleMap : [string]string = map{"a" => "apple", "b" => "bear", "c" => "candy"}
for (Key->Value : ExampleMap):
    Print("{Value} in ExampleMap at key {Key}")

Hinzufügen und Ändern von Elementen in einer Karte

Du kannst Elemente zu einer Map-Variable hinzufügen, indem du den Schlüssel in einer Map auf einen bestimmten Wert setzt. Zum Beispiel set ExampleMap["d"] = 4. Bestehende Schlüssel-Wert-Paare können aktualisiert werden, indem einem bereits in der Map vorhandenen Schlüssel ein Wert zugewiesen wird. Der Zugriff auf ein Element in einer Karte ist ein failable expression und kann nur in einem failure context verwendet werden, z. B. in einem if expression. Beispiel:

var ExampleMap : [string]int = map{"a" => 1, "b" => 2, "c" => 3}
# Modifying an existing element
if (set ExampleMap["b"] = 3, ValueOfB := ExampleMap["b"]):
    Print("Updated key b in ExampleMap to {ValueOfB}")
# Adding a new element
if (set ExampleMap["d"] = 4, ValueOfD := ExampleMap["d"]):
    Print("Added a new key-value pair to ExampleMap with value {ValueOfD}")

Entfernen von Elementen aus einer Karte

Elemente können aus einer Map-Variable entfernt werden, indem du eine neue Map erstellst, die den Schlüssel, den du entfernen möchtest, ausschließt. Im Folgenden findest du ein Beispiel für eine Funktion, die das Entfernen von [string]int Karten ermöglicht.

# Removes an element from the given map and returns a new map without that element
RemoveKeyFromMap(ExampleMap:[string]int, ElementToRemove:string):[string]int=
    var NewMap:[string]int = map{}
    # Concatenate Keys from ExampleMap into NewMap, excluding ElementToRemove
    for (Key -> Value : ExampleMap, Key <> ElementToRemove):
        set NewMap = ConcatenateMaps(NewMap, map{Key => Value})
    return NewMap

Schwache Map

Der Typ weak_map ist ein Supertyp des Typs map. Du verwendest eine weak_map in den meisten Fällen wie den Typ map, allerdings gibt es folgende Ausnahmen:

• Du kannst nicht abfragen, wie viele Elemente eine weak_map enthält, da weak_map kein Length-Element hat.

• Du kannst nicht durch die Elemente einer weak_map iterieren.

• Du kannst ConcatenateMaps() nicht für eine weak_map verwenden.

Ein weiterer Unterschied ist, dass die Typdefinition für eine weak_map erfordert, dass du die Schlüssel-Wert-Paar-Typen mit der Funktion weak_map definierst, wie z. B. MyWeakMap:weak_map(string, int) = map{}, die eine weak map mit dem Namen MyWeakMap definiert, die einen String-Schlüssel und einen Integer-Wert hat. Da weak_map ein Supertyp von map ist, kannst du es mit einem Standard map{} initialisieren.

Im Folgenden wird ein Beispiel für die Erstellung einer weak_map-Variablen und den Zugriff auf ein Element in der weak map gezeigt:

ExampleFunction():void=
    var MyWeakMap:weak_map(int, int) = map{} # Supertype of the standard map, so it can be assigned from the standard map
    if: 
        set MyWeakMap[0] = 1 # Same means of mutation of a particular element as the standard map
    then:
        if (Value := MyWeakMap[0]):
            Print("Value of map at key 0 is {Value}")
    set MyWeakMap = map{0 => 2} # Same means of mutation of the entire map as the standard map

Dauerhafter Typ

Eine Karte ist dauerhaft, wenn sowohl der Schlüssel als auch die Werttypen dauerhaft sind. Wenn eine Map dauerhaft ist, bedeutet das, dass du sie in deiner modulbereichsbezogenen Variable weak_map verwenden kannst und die Werte dann über Spielsitzungen hinweg erhalten bleiben. Für weitere Einzelheiten zur Persistenz in Verse, schau dir Using Persistable Data in Verse an.