Mappage

Un mappage est un type de conteneur qui contient des paires clé-valeur, c'est-à-dire une valeur mappée en une autre. Les éléments d'un mappage sont classés en fonction de l'ordre des paires clé-valeur lors de la création du mappage ; les éléments du mappage sont accessibles à l'aide des clés uniques que vous définissez.

Par exemple, si vous souhaitez connaître le nombre de fois où vous rencontrez un mot, vous pouvez créer un mappage en utilisant le mot comme clé et son nombre comme valeur.

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

Cliquez sur l'image pour l'agrandir.

Si vous utilisez plusieurs fois la même clé lors de l'initialisation d'un mappage, le mappage ne conserve que la dernière valeur fournie pour cette clé. Dans l'exemple suivant, WordCount dispose uniquement de la paire clé-valeur "pomme" => 2. Les paires "pomme" => 0 et "pomme" => 1 sont ignorées.

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

Types de clés pris en charge

Vous pouvez utiliser tout type de paires clé-valeur à condition que le type de clé soit comparable, car il doit exister un moyen de vérifier si une clé existe déjà pour un mappage.

Vous pouvez utiliser les types de clés suivants :

• logic

• int

• float

• char

• string

• enum

• Une classe, si elle est comparable

• Une option, si le type d'élément est comparable

• Une matrice, si le type d'élément est comparable

• Un mappage si les types de clés et de valeurs sont comparables

• Un tuple si tous les éléments du tuple sont comparables

Longueur de mappage

Vous pouvez obtenir le nombre de paires clé-valeur d'un mappage en accédant au champ Length du mappage. Par exemple, map{"a" => "apple", "b" => "bear", "c" => "candy"}.Length renvoie 3.

Accéder aux éléments d’un mappage

Vous pouvez accéder à un élément d'un mappage en utilisant une clé, par exemple WordCount["pomme"].

L'accès à un élément d'un mappage est une expression faillible et ne peut être utilisé que dans un contexte d'échec, comme une expression if. Par exemple :

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

Ajouter et modifier des éléments dans un mappage

Vous pouvez ajouter des éléments à une variable de mappage en définissant la clé dans un mappage sur une valeur spécifique. Par exemple set ExampleMap["d"] = 4. Les paires clé-valeur existantes peuvent être mises à jour en assignant également une valeur à une clé qui existe déjà dans le mappage. L'ajout d'un élément à un mappage est une expression faillible et ne peut être utilisé que dans un contexte d'échec, comme une expression if. Par exemple :

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}")

Supprimer des éléments d’un mappage

Les éléments peuvent être supprimés d'une variable de mappage en créant un nouveau mappage qui exclut la clé que vous souhaitez supprimer. Un exemple de fonction permettant de supprimer des éléments de mappages [string]int est fourni ci-dessous.

# 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

Mappage faible

Le type weak_map est un super-type du type map (mappage). Vous utilisez un weak_map de la même manière que le type map dans la plupart des cas, mais avec les exceptions suivantes :

• Il n'est pas possible d'interroger le nombre d’éléments qu’un weak_map contient, car weak_map ne possède pas de membre Length.

• Il n'est pas possible d'itérer les éléments d’un weak_map.

• Il n'est pas possible d'utiliser ConcatenateMaps() sur un type weak_map.

Une autre différence réside dans le fait que la définition de type pour un weak_map exige de spécifier les types des paires clé-valeur à l’aide de la fonction weak_map, par exemple : MyWeakMap:weak_map(string, int) = map{}, qui définit un mappage faible nommée MyWeakMap avec une clé de type chaîne associée à des valeurs entières. Dans la mesure où weak_map est un super-type de map, il est possible de l'initialiser avec un type map{} standard.

L'exemple suivant décrit la création d'une variable weak_map et l'accès à un élément du mappage faible :

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

Type persistant

Un mappage est persistant si les types clé et valeur sont persistants. Lorsqu'une carte est persistance, cela signifie que vous pouvez l'utiliser dans vos variables weak_map à étendue de module et faire persister leurs valeurs d'une session de jeu à une autre. Pour en savoir plus sur la persistance dans Verse, consultez la rubrique Utiliser des données persistantes dans Verse.