Swift #21: Diccionarios (Dictionary)

Un diccionario es una estructura de datos SIN ORDEN que asocia una llave a un valor. Swift ofrece varias sintaxis para crear un diccionario:

let result1 = Dictionary<Type1: Type2>()
let result2 = Dictionary(grouping: Collection, by: Closure)
let result3: Dictionary<Type1: Type2> = Dictionary()
let result4: [Type1: Type2] = [:]
let result5: [Type1: Type2] = [llave1:valor1, llave2:valor2, ...]
// En caso de que se pueda inferir el tipo:
let result6 = [llave1:valor1, llave2:valor2, ...]

El segundo constructor, init(grouping:by:), crea un nuevo diccionario a partir de una colección, cuyas llaves vienen dadas por el closure del segundo parámetro y los valores son los arreglos de elementos asignados a dicha llave. Cada valor va a devolver una llave; al final se agrupan todos los valores que devuelven la misma llave.

let students = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]
let studentsByLetter = Dictionary(grouping: students, by: { $0.first! })
// ["E": ["Efua"], "K": ["Kofi", "Kweku"], "A": ["Abena", "Akosua"]]

Leer o modificar un valor del diccionario

Se usa la notación de índice para leer y escribir una posición del diccionario.

Si se usa un índice existente al modificar el diccionario, se sobrescribe el valor almacenado (e.g. result["C"]). Si no existe, entonces crea un nuevo elemento (e.g. result["D"]). Escribir nil se traduce en eliminar la posición de memoria.

var result = ["A": "Salud", "B": "Dinero", "C": "Amor"]
print(result["C"]) // Optional("Amor")
result["C"] = "Casa" // Se sobrescribe
print(result["C"]) // Optional("Casa")
print(result["D"]) // nil
result["D"] = "Carro" // Se crea uno nuevo
print(result["D"]) // Optional("Carro")

if let carro = result["D"] {
  print(carro) // "Carro"
}

result["D"] = nil // Se elimina la posición de memoria
print(result["D"]) // nil

Recorrer un diccionario

Se usa un ciclo for in para recorrer el diccionario donde cada elemento es una tupla con la llave y el valor.

var result = ["A": "Salud", "B": "Dinero", "C": "Amor"]
for (letra, deseo) in result {
  print("\(letra) - \(deseo)"
}
// A - Salud
// B - Dinero
// C - Amor

Diccionario como estructura de datos

El tipo Dictionary<T: Hashable, U> ofrece algunos métodos y propiedades:

• count
• isEmpty
• keys: Retorna todas las llaves del diccionario.
• values: Retorna todos los valores del diccionario.
• sorted(by:): Retorna los elementos del diccionario (como tuplas llave/valor) en un arreglo ordenado según el closure.
• randomelement(): Retorna un elemento aleatorio del diccionario (como tupla llave/valor). Si el diccionario está vacío, retorna nil.
• updateValue(_:forKey:): Actualiza el valor almacenado en el diccionario para la llave dada, o agrega un nuevo elemento llave/valor si la llave no existe. Retorna el valor anterior que fue reemplazado, o nil si no existía nada antes.
• removeValue(forKey:): Elimina un elemento (llave/valor) del diccionario. Retorna el elemento eliminado o nil si no existía.

var result = ["A": "Salud", "B": "Dinero", "C": "Amor"]
result.updateValue("Casa", forKey: "A")
result.removeValue(forKey: "B")
print(result) // ["A": "Casa", "C": "Amor"]

Como el diccionario no tiene orden, el método sorted(by:) conviene mucho para trabajar el diccionario:

let result = ["A": "Salud", "B": "Dinero", "C": "Amor"]
let array = result.sorted(by: { $0.1 < $1.1 })
print(array) // [(key: "C", value: "Amor"), (key: "B", value: "Dinero"), (key: "A", value: "Salud")]

Las llaves (keys) y valores (values) del diccionario son secuencias de tipo Keys y Values, respectivamente, definidas dentro de la estructura Dictionary. Estas se pueden convertir en arreglos con el inicializador Array().

let result = ["A": "Salud", "B": "Dinero", "C": "Amor"]
let array = Array(result.values)
print(array) // ["Salud", "Dinero", "Amor"]