Mapa

Un mapa es un tipo de contenedor que contiene pares clave-valor, que son asignaciones de un valor a otro valor. Los elementos de un mapa se ordenan según el orden de los pares clave-valor cuando creas el mapa, y accedes a los elementos del mapa utilizando las claves únicas que defines.

Por ejemplo, si quieres llevar un recuento de las veces que te encuentras con una palabra, puedes crear un mapa utilizando la palabra como clave y su recuento como valor.

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

Haz clic en la imagen para ampliarla.

Si utilizas la misma clave varias veces al inicializar un mapa, el mapa solo conservará el último valor proporcionado para esa clave. En el siguiente ejemplo, WordCount solo tendrá el par clave-valor "apple" => 2. Los pares "apple" => 0 y "apple" => 1 se descartan.

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

Tipos de claves admitidas

Los pares clave-valor pueden ser de cualquier tipo, siempre que el tipo de clave sea comparable, porque es necesario que haya una forma de comprobar si una clave ya existe para un mapa.

Los siguientes tipos pueden utilizarse como claves:

• logic

• int

• float

• char

• string

• enum

• Una clase, si es comparable.

• Una opción, si el tipo de elemento es comparable.

• Una matriz, si el tipo de elemento es comparable.

• Un mapa si los tipos de clave y de valor son comparables.

• Una tupla, si todos sus elementos son comparables

Longitud del mapa

Puedes obtener el número de pares clave-valor de un mapa accediendo al campo Length del mapa. Por ejemplo, map{"a" => "apple", "b" => "bear", "c" => "candy"}.Length devuelve 3.

Cómo acceder a los elementos de un mapa

Puedes acceder a un elemento de un mapa utilizando una clave, por ejemplo WordCount[“manzana”].

Acceder a un elemento en un mapa es una expresión falible y solo puede utilizarse en un contexto de fallo, como una expresión `if`. Por ejemplo:

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

Cómo añadir y modificar elementos en un mapa

Puedes añadir elementos a una variable de mapa al establecer la clave de un mapa en un valor específico. Por ejemplo, set ExampleMap["d"] = 4. Los pares clave-valor existentes pueden actualizarse al asignar de forma similar un valor a una clave que ya existe en el mapa. Añadir un elemento a un mapa es una expresión falible y solo puede utilizarse en un contexto de fallo, como una expresión `if`. Por ejemplo:

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

Cómo eliminar elementos de un mapa

Los elementos pueden eliminarse de una variable del mapa al crear un nuevo mapa que excluya la clave que quieres eliminar. A continuación se proporciona un ejemplo de una función con la que se produce la eliminación de los mapas [string]int.

# 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

Weak Map

El tipo weak_map es un supertipo del tipo map. Utilizarías un weak_map de forma similar a como utilizarías el tipo map en la mayoría de los casos, pero con las siguientes excepciones:

• No puedes consultar cuántos elementos contiene un weak_map porque weak_map no tiene un miembro Length.

• No puedes iterar por los elementos de un weak_map.

• No puedes usar ConcatenateMaps() en un weak_map.

Otra diferencia es que la definición de tipo para un weak_map requiere que definas los tipos de pares clave-valor utilizando la función weak_map, por ejemplo, MyWeakMap:weak_map(string, int) = map{}, que define un mapa `weak` nombrado MyWeakMap, que tendrá una clave de cadena emparejada con un valor entero. Como weak_map es un supertipo de map, puedes inicializarlo con un map{} estándar.

A continuación se muestra un ejemplo de creación de una variable weak_map y de acceso a un elemento del mapa `weak`:

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

Un mapa es persistente si tanto el tipo de clave como el de valor son persistentes. Cuando un mapa es persistente, significa que puedes usarla en tus variables weak_map de tu ámbito de módulo y hacer que sus valores se mantengan a lo largo de las sesiones de juego. Para obtener más información sobre la persistencia en Verse, consulta la sección Cómo utilizar datos persistentes en Verse.