Tutorial de Swift

Funciones Swift

Diccionario Swift

Un diccionario Swift se usa para almacenar una colección desordenada de datos del mismo tipo. El diccionario Swift fuerza la verificación del tipo de los elementos; si los tipos son diferentes, se producirá un error.

En un diccionario Swift, cada valor (value) está asociado con una clave (key) única, y la clave actúa como identificador del dato de ese valor en el diccionario.

A diferencia de los elementos de un array, los elementos de un diccionario no tienen un orden específico. Usamos un diccionario cuando necesitamos acceder a los datos mediante un identificador (clave), un método muy similar a la forma en que usamos un diccionario en el mundo real para buscar el significado de una palabra.

La clave de un diccionario Swift no tiene restricciones de tipo, puede ser entera o cadena, pero debe ser única.

Si se crea un diccionario y se asigna a una variable, el diccionario creado es modificable. Esto significa que después de crear el diccionario, se pueden cambiar sus elementos añadiendo, eliminando o modificando. Si se asigna un diccionario a una constante, el diccionario no es modificable, y tanto su tamaño como su contenido no se pueden cambiar.

Crear diccionario

Podemos usar la siguiente sintaxis para crear un diccionario vacío de un tipo específico:

var someDict =  [KeyType: ValueType]()

A continuación se muestra la sintaxis simple para crear un diccionario vacío con claves de tipo Int y valores de tipo String:

var someDict = [Int: String]()

El siguiente es un ejemplo de creación de un diccionario:

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

Acceder al diccionario

Podemos acceder a los elementos del diccionario mediante la clave, la sintaxis es la siguiente:

var someVar = someDict[key]

Podemos aprender a crear, inicializar y acceder a un diccionario mediante el siguiente ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

var someVar = someDict[1]

print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

El resultado de ejecutar el programa anterior es:

key = 1 的值为 Optional("One")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")

Modificar diccionario

Podemos usarupdateValue(forKey:)para agregar o actualizar el contenido del diccionario. Si la clave no existe, se agrega el valor; si existe, se modifica el valor correspondiente. El método updateValue(_:forKey:) devuelve un valor Optional. Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

var oldVal = someDict.updateValue("One 新的值", forKey: 1)

var someVar = someDict[1]

print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

El resultado de ejecutar el programa anterior es:

key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")

También puedes modificar el valor de un diccionario mediante una clave específica, como se muestra a continuación:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

var oldVal = someDict[1]
someDict[1] = "One 新的值"
var someVar = someDict[1]

print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

El resultado de ejecutar el programa anterior es:

key = 1 旧的值 Optional("One")
key = 1 的值为 Optional("One 新的值")
key = 2 的值为 Optional("Two")
key = 3 的值为 Optional("Three")

Eliminar pares clave-valor

Podemos usarremoveValueForKey()el método para eliminar pares clave-valor del diccionario. Si la clave existe, el método devuelve el valor eliminado; si no existe, devuelve nil. Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

var removedValue = someDict.removeValue(forKey: 2)

print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

El resultado de ejecutar el programa anterior es:

key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")

También puedes eliminar un par clave-valor asignando nil al valor de la clave especificada. Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

someDict[2] = nil

print( "key = 1 的值为 \(someDict[1])" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

El resultado de ejecutar el programa anterior es:

key = 1 的值为 Optional("One")
key = 2 的值为 nil
key = 3 的值为 Optional("Three")

Recorrer el diccionario

Podemos usarfor-inun bucle para recorrer los pares clave-valor de un diccionario. Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (key, value) in someDict {
   print("字典 key \(key) -  字典 value \(value)")
}

El resultado de ejecutar el programa anterior es:

字典 key 2 -  字典 value Two
字典 key 3 -  字典 value Three
字典 key 1 -  字典 value One

También podemos usar el método enumerate() para recorrer el diccionario, que devuelve el índice del diccionario y los pares (key, value). Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (key, value) in someDict.enumerated() {
    print("字典 key \(key) -  字典 (key, value) 对 \(value)")
}

El resultado de ejecutar el programa anterior es:

字典 key 0 -  字典 (key, value) 对 (2, "Two")
字典 key 1 -  字典 (key, value) 对 (3, "Three")
字典 key 2 -  字典 (key, value) 对 (1, "One")

Convertir diccionario en array

Puedes extraer los pares clave-valor del diccionario y convertirlos en arrays separados. Ejemplo:

import Cocoa

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

print("输出字典的键(key)")

for (key) in dictKeys {
    print("\(key)")
}

print("输出字典的值(value)")

for (value) in dictValues {
    print("\(value)")
}

El resultado de ejecutar el programa anterior es:

输出字典的键(key)
2
3
1
输出字典的值(value)
Two
Three
One

Propiedad count

Podemos usar la propiedad de solo lecturacountpara calcular cuántos pares clave-valor tiene el diccionario:

import Cocoa

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]

print("someDict1 含有 \(someDict1.count) 个键值对")
print("someDict2 含有 \(someDict2.count) 个键值对")

El resultado de ejecutar el programa anterior es:

someDict1 含有 3 个键值对
someDict2 含有 2 个键值对

Propiedad isEmpty

Y podemos, mediante la propiedad de solo lectura,isEmptydeterminar si el diccionario está vacío; devuelve un valor booleano.

import Cocoa

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()

print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")

El resultado de ejecutar el programa anterior es:

someDict1 = false
someDict2 = false
someDict3 = true

Otras extensiones

Funciones Swift