Maps

¿Qué es un map?

Un map es una colección que almacena pares clave-valor. Piensa en él como un diccionario: buscas una palabra (la clave) y encuentras su definición (el valor).

Los arrays usan números (índices) para encontrar valores. Los maps usan cualquier valor — generalmente strings — como claves. Esto los hace perfectos para situaciones donde quieres asociar una cosa con otra.

Clave      →  Valor
"nombre"   →  "Alice"
"edad"     →  "25"
"ciudad"   →  "Berlín"

Crear un map

En Nyx, creas un map con Map.new():

fn main() {
    var m: Map = Map.new()
    print(m)
}

Los maps empiezan vacíos. Los llenas insertando pares clave-valor.

Insertar valores

Usa .insert(clave, valor) para agregar entradas:

fn main() {
    var m: Map = Map.new()

    m.insert("nombre", "Alice")
    m.insert("lenguaje", "Nyx")
    m.insert("version", "0.12.0")

    print(m)
}

Si insertas una clave que ya existe, el valor viejo se reemplaza:

fn main() {
    var m: Map = Map.new()

    m.insert("color", "rojo")
    print(m.get("color"))    // rojo

    m.insert("color", "azul")
    print(m.get("color"))    // azul
}

Obtener valores

Usa .get(clave) para obtener un valor:

fn main() {
    var m: Map = Map.new()
    m.insert("capital", "París")
    m.insert("poblacion", "67 millones")

    print(m.get("capital"))       // París
    print(m.get("poblacion"))     // 67 millones
}

Verificar si una clave existe

Usa .contains(clave) para verificar si una clave está en el map:

fn main() {
    var m: Map = Map.new()
    m.insert("nombre", "Nyx")

    print(m.contains("nombre"))      // true
    print(m.contains("version"))     // false
}

Esto es útil para evitar errores cuando una clave podría no existir.

Eliminar entradas

Usa .remove(clave) para borrar un par clave-valor:

fn main() {
    var m: Map = Map.new()
    m.insert("x", "10")
    m.insert("y", "20")

    print(m.size())    // 2

    m.remove("x")
    print(m.size())    // 1
    print(m.contains("x"))    // false
}

Tamaño del map

Usa .size() para saber cuántas entradas tiene un map:

fn main() {
    var m: Map = Map.new()
    print(m.size())    // 0

    m.insert("a", "1")
    m.insert("b", "2")
    m.insert("c", "3")
    print(m.size())    // 3
}

Cuándo usar maps vs arrays

Usa un array cuando:

Tienes una lista ordenada de elementos.
Accedes a elementos por su posición (índice 0, 1, 2...).
El orden importa.

Usa un map cuando:

Quieres buscar valores por nombre (clave).
Cada elemento tiene un identificador único.
El orden no importa.

Por ejemplo, una lista de puntajes por nombre de jugador es un caso perfecto para un map:

fn main() {
    var puntajes: Map = Map.new()
    puntajes.insert("Alice", "95")
    puntajes.insert("Bob", "87")
    puntajes.insert("Charlie", "92")

    print(puntajes.get("Bob"))    // 87
}

Ejemplo práctico: contador de palabras

Contar cuántas veces aparece cada palabra en una lista:

fn main() {
    let palabras: Array = ["hola", "mundo", "hola", "nyx", "hola", "mundo"]

    var conteos: Map = Map.new()
    var i: int = 0
    while i < palabras.length() {
        let palabra: String = palabras[i]
        if conteos.contains(palabra) {
            let actual: int = string_to_int(conteos.get(palabra))
            conteos.insert(palabra, int_to_string(actual + 1))
        } else {
            conteos.insert(palabra, "1")
        }
        i += 1
    }

    print("hola: " + conteos.get("hola"))      // hola: 3
    print("mundo: " + conteos.get("mundo"))     // mundo: 2
    print("nyx: " + conteos.get("nyx"))         // nyx: 1
}

Nota: los valores del map se almacenan como strings en Nyx, así que convertimos entre int y String con string_to_int() e int_to_string().

Ejemplo práctico: configuración simple

fn cargar_defaults() -> Map {
    var config: Map = Map.new()
    config.insert("port", "8080")
    config.insert("host", "localhost")
    config.insert("debug", "false")
    return config
}

fn main() {
    let cfg: Map = cargar_defaults()

    print("Servidor: " + cfg.get("host") + ":" + cfg.get("port"))
    // Servidor: localhost:8080
}

Ejercicios

Crea un map que almacene las capitales de 5 países. Después imprime la capital de cada país.

Escribe una función map_tiene_valor(m: Map, valor: String) -> bool que devuelva true si alguna clave en el map tiene el valor dado. Pista: necesitarás verificar cada clave que conozcas.

Escribe un programa que cuente cuántas veces aparece cada carácter en un string. Pista: recorre el string con .charAt(), convierte cada carácter a string con char_to_string(), y usa un map para contar.

Crea un "directorio telefónico" como map con 5 nombres y números de teléfono. Escribe una función que tome un nombre y el map, e imprima el número o "No encontrado".

Escribe una función que tome dos maps y devuelva un nuevo map con todas las entradas de ambos. Si ambos maps tienen la misma clave, usa el valor del segundo map.

Resumen

Los maps almacenan pares clave-valor: var m: Map = Map.new()
.insert(clave, valor) agrega o actualiza una entrada.
.get(clave) obtiene un valor.
.contains(clave) verifica si una clave existe.
.remove(clave) elimina una entrada.
.size() devuelve la cantidad de entradas.
Los valores del map son strings — convierte con int_to_string() y string_to_int() según sea necesario.
Usa arrays para listas ordenadas, maps para búsquedas por nombre.

Siguiente capítulo: Structs →

← Anterior: Strings Siguiente: Structs →