Mapa

Um mapa é um token de contêiner que contém pares de chave e valor, que mapeiam de um valor para outro. Os elementos em um mapa são ordenados com base na ordem dos pares de chave e valor quando o mapa é criado, e é possível acessar esses elementos no mapa usando as chaves exclusivas que você define.

Por exemplo, se você deseja manter uma contagem de quantas vezes encontra uma palavra, pode criar um mapa usando a palavra como chave e sua contagem como valor.

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

Clique na imagem para ampliar.

Se usar a mesma chave várias vezes ao inicializar um mapa, este manterá apenas o último valor fornecido para essa chave. No exemplo a seguir, WordCount terá apenas o par de chave e valor "apple" => 2. Os pares "apple" => 0 e "apple" => 1 são descartados.

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

Tipos de chave compatíveis

Os pares de valores-chave podem ser de qualquer tipo, desde que o tipo de chave seja comparável, pois é necessário haver uma maneira de verificar se já existe uma chave para um mapa.

Os seguintes tipos podem ser usados como chaves:

• logic

• int

• float

• char

• string

• enum

• Uma classe, se for comparável

• Uma opção, se o tipo de elemento for comparável

• Uma matriz, se o tipo de elemento for comparável

• Um mapa se os tipos de chave e valor forem comparáveis

• Uma tupla se todos os elementos na tupla forem comparáveis

Extensão do mapa

Você pode obter o número de pares de chave e valor em um mapa acessando o campo Length nesse mapa. Por exemplo, map{"a" => "apple", "b" => "bear", "c" => "candy"}.Length retorna 3.

Como acessar elementos em um mapa

Você pode acessar um elemento em um mapa usando uma chave, por exemplo WordCount["apple"].

Acessar um elemento em um mapa é uma expressão falível e só pode ser usado em um contexto de falha, como uma expressão if. Por exemplo:

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

Como adicionar e modificar elementos em um mapa

Você pode adicionar elementos a uma variável de mapa definindo a chave em um mapa para um valor específico. Por exemplo set ExampleMap["d"] = 4. Os pares de valor-chave existentes podem ser atualizados atribuindo-se de forma semelhante um valor a uma chave que já existe no mapa. Adicionar um elemento a um mapa é uma expressão falível e só pode ser usado em um contexto de falha, como uma expressão if. Por exemplo:

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

Como remover elementos de um mapa

Os elementos podem ser removidos de uma variável de mapa criando um novo mapa que exclui a chave que você deseja remover. Um exemplo de função que fornece remoção de mapas [string]int é fornecido abaixo.

# 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

Mapa fraco

O tipo weak_map é um supertipo do tipo map. Você pode usar weak_map e map de maneiras semelhantes na maioria dos casos, mas com as seguintes exceções:

• Você não pode consultar quantos elementos um weak_map contém, pois weak_map não tem um membro Length.

• Não é possível iterar pelos elementos de um weak_map.

• Não é possível usar ConcatenateMaps() em um weak_map.

Outra diferença é que a definição de tipo para weak_map exige que você defina os tipos de pares de chave e valor usando a função weak_map, como MyWeakMap:weak_map(string, int) = map{}, que define um mapa fraco denominado MyWeakMap, que terá uma chave de string emparelhada com um valor inteiro. Como weak_map é um supertipo de map, você pode inicializá-lo com um map{} padrão.

O exemplo a seguir mostra a criação de uma variável weak_map e o acesso a um elemento no mapa fraco:

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

Tipo persistente

Um mapa é persistente quando os tipos de chave e valor são persistentes. Quando um mapa é persistente, você pode usá-la nas variáveis weak_map com escopo de módulo e fazer com que seus valores persistam entre as sessões de jogo. Consulte mais detalhes sobre a persistência em Verse em Como usar dados persistentes em Verse.