En el Tutorial Swift de hoy aprenderemos acerca de los tres tipos de colecciones de datos que ofrece Swift, conocidas como arrays, sets, y dictionaries.
Las colecciones son de gran utilidad al momento de almacenar arreglos de valores:
- Array: Colecciones de valores ordenados.
- Set: Colecciones no ordenadas de valores únicos.
- Dictionaries: Colecciones no ordenadas de asociaciones llave-valor.
Es decir, las colecciones de datos en Swift nos permiten agrupar datos u objetos de una manera particular, ya sea como una lista de elementos únicos o repetidos, o simplemente una lista de conjuntos.
[better-ads type=’banner’ banner=’159′ ]
Cuando trabajamos con arrays, sets y dictionaries siempre se tiene claro los tipos de valores y las llaves que pueden almacenar. Esto significa que jamás podremos insertar por error un valor de un tipo de dato que no sea el de la colección, al mismo tiempo que nos brinda la seguridad sobre el tipo de valores que se van a recuperar de la misma.
Mutabilidad
Si crea un array, un set o un dictionary, y lo asigna a una variable, la colección que se crea será mutable. Esto quiere decir que se puede cambiar (o mutar) la colección agregando, eliminando o cambiando elementos de la misma. Si asigna una array, un set o un dictionary a una constante, la colección será inmutable, y su tamaño y contenido no se podrán cambiar.
Se considera una buena práctica crear colecciones inmutables en todos los casos en los que la colección no vaya a ser modificada, ya que con esto le estamos permitiendo al compilador de Swift optimizar el rendimiento de estas colecciones.
Array
Al igual que en otros lenguajes de programación, en Swift también contamos con los Arreglos. En caso de que no se conozca de que estamos hablando, se podría decir que un array o arreglo es un conjunto de datos de un mismo tipo ordenados de forma lineal.
Los componentes de un array se han de referenciar por medio del nombre del array y un índice de desplazamiento para indicar el componente deseado. A continuación veremos dos ejemplos de como declarar un Array y su inicialización, ambos ejemplos son equivalentes:
let someArray: Array = ["Nery", "Carlos", "Gise"] let otherArray: [String] = ["Nery", "Carlos", "Gise"]
En ambos casos declaramos un Array de cadenas, someArray y otherArray representan constantes que nombran el arreglo para que luego pueda ser referenciado. A los elementos de un Array se puede acceder a través de subíndices especificando un valor de índice válido entre corchetes: someArray [0] aquí hacemos referencia al elemento en el índice 0, “Nery”.
Creación de un Array vacío
Podemos crear un arreglo vacío de un cierto tipo de dato utilizando la sintaxis de inicialización:
var someInts = [Int]()
print("someInts es de tipo [Int] con \(someInts.count) elementos.")la salida en pantalla sería:
someInts es de tipo [Int] con 0 elementos.
Tengamos en cuenta que el tipo de la variable someInts se infiere a partir del tipo de dato con el que la inicializamos.
Otra opción hubiera sido:
var bucketList: Array<String>
var anotherList: [String]
Creando un Array con valores por defecto
Los Arrays en Swift también proporcionan un inicializador para la creación de una matriz de cierto tamaño, con todos sus valores establecidos a un mismo valor por defecto.
[better-ads type=’banner’ banner=’160′ ]
A este inicializador se le pasa el número de elementos que se añade al nuevo arreglo (llamado count) y un valor por defecto del tipo de dato apropiado (llamado repeating):
var tresDoubles = [Double](repeating: 1.0, count: 3)
print("tresDoubles es de tipo [Double] y sus valores son: (tresDoubles)")la salida en pantalla:
tresDoubles es de tipo [Double] y sus valores son: [1.0, 1.0, 1.0]
Una alternativa pudiera ser:
var myBucketList: [String] = ["Climb Mt. Everest"]o esta otra versión donde Swift infiere el tipo de dato que conforma el Array:
var myBucketList = ["Climb Mt. Everest"]También podemos crear un Array multidimensionales anidando pares de corchetes, en el que el nombre del tipo de dato de los elementos está contenido en el par más interior de corchetes.
Por ejemplo, puede crear un Array tridimensional de números enteros utilizando tres conjuntos de corchetes:
var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]Cuando se accede a los elementos en un Array multidimensional, en este caso de dos dimensiones, el índice más a la izquierda del subíndice se refiere al elemento en el índice “horizontal” del arreglo externo y lógicamente el de la derecha se refiere al elemento en el índice vertical.
Esto significa que en el ejemplo anterior, array3D [0] se refiere a [[1, 2], [3, 4]], array3D [0] [1] se refiere a [3, 4], y array3D [0] [1 ] [1] se refiere al valor 4.
Accediendo y Modificando un Array
Veamos a continuación como añadir más elementos a nuestra lista de deseos:
var bucketList: Array<String>
var myBucketList = ["escalar el Monte Everest."]
myBucketList.append("volar en globo.")
myBucketList.append("bucear en las Islas Galápagos.")
myBucketList.append("saltar en paracaidas.")
for myWish in myBucketList {
print("Yo quiero \(myWish)")
} // for
myBucketList.append("ir a las Piramides de Egipto.")
myBucketList.remove(at: 0)
print("")
for myWish in myBucketList[0...(myBucketList.count - 1)] {
print("Yo quiero \(myWish)")
} // forla salida en pantalla de este código sería:
Yo quiero escalar el Monte Everest. Yo quiero volar en globo. Yo quiero bucear en las Islas Galápagos. Yo quiero saltar en paracaidas. Yo quiero volar en globo. Yo quiero bucear en las Islas Galápagos. Yo quiero saltar en paracaidas. Yo quiero ir a las Piramides de Egipto.
En el anterior ejemplo hemos agrandado nuestro arreglo, hemos eliminado registros y hemos iterado sobre sus elementos incluso haciendo uso de rangos, todo esto utilizando varios métodos miembros de Array, pero estos no son todos, hay muchos más que los exhorto a descubrir.
Set
Un Set almacena valores distintos de un mismo tipo en una colección sin orden definido, ya lo se, lo que intento decir es que un Set de tipo String solamente almacenará cadenas de texto y ninguna de estas podrán ser iguales, todas cadenas donde sus valores no podrán repetirse, tiene que ser únicos.
Usualmente se hace uso de un Set en lugar de un Array cuando el orden de los elementos no sea importante, o cuando es necesario asegurarse de que un artículo sólo aparece una sola vez.
Creando e inicializando un Set vacío
Podemos crear un Set vacío de un cierto tipo de dato utilizando la sintaxis de inicialización:
var letras = Set()
print("letras es de tipo Set con \(letras.count) elementos.")la salida en pantalla:
letras es de tipo Set con 0 elementos.
Creando un Set a partir de un Array literal
También se puede inicializar un Set con un Array literal, como una forma abreviada de escribir uno o más valores como una colección Set. El siguiente ejemplo crea un Set denominado generosFavoritos para almacenar valores de cadena:
var generosFavoritos: Set = ["Rock", "Clásica", "Hip hop"]En la variable generosFavoritos almacenamos los géneros musicales de nuestra preferencia, y se que estarán de acuerdo conmigo, en que no tiene sentido que quepa la posibilidad de que hayan valores repetidos, sencillamente esto no tendría sentido.
Aquí hemos inicializado nuestro Set con tres valores de cadena (“Rock”, “Clásica” y “Hip hop”), estos escritos dentro de un Array literal.
La línea del ejemplo anterior también pudo haberse escrito de la siguiente forma:
var generosFavoritos: Set = ["Rock", "Clásica", "Hip hop"]…el tipo de dato String es inferido por Swift dado los valores con los que se ha iniclializado el Set en cuestión.
Accediendo y modificando un Set
Se puede acceder y modificar un conjunto a través de sus métodos y propiedades. Para averiguar el número de elementos de un Set, nos apoyamos en la propiedad count:
print("Mis géneros de música favoritos son \(generosFavoritos.count).")Podemos agregar un nuevo elemento a un Set haciendo una llamada al método insert(_:):
generosFavoritos.insert("Jazz")Ante la necesidad de eliminar un elemento de un Set lo podemos lograr mediante el método remove(_ :), el cual elimina el elemento si es un miembro del Set, devolviendo el valor eliminado, o nil en caso de que el mismo no estuviese contenido en el Set.
Por otra parte, todos los elementos de un Set se pueden eliminar con el método removeAll ().
if let eliminarGenero = generosFavoritos.remove("Hip hop") {
print("El género \(eliminarGenero) ha sido eliminado.")
} // if letUniones
Imaginemos que vamos de compras, a pos de algunas frutas para luego en casa preparar un coctel:
print("Nuestra cesta de compras contiene: \n")
var groceryBag: Set = ["Manzanas", "Naranjas", "Piñas"]
for food in groceryBag {
print(food)
} // for
print("\nTenemos ya los platanos? \n")
if groceryBag.contains("Platanos") {
print("Yehaaa, tienes los platanos in la bag!")
} else {
print("No platanos in the bag, regresa a por ellos!")
} // elsepues nos falta comprar plátano, al mismo tiempo que advertimos la presencia de un amiga que se encuentra también haciendo las compras, luego de una corta charla acordamos terminar nuestras compras juntos y para ellos necesitamos ver todo cuanto tenemos en ambas cestas para programar mejor el recorrido en búsqueda de los que a ambos nos falta:
print("Nuestra cesta de compras contiene: \n")
var groceryBag: Set = ["Manzanas", "Naranjas", "Piñas"]
for food in groceryBag {
print(food)
} // for
print("\nTenemos ya los platanos? \n")
if groceryBag.contains("Platanos") {
print("Yehaaa, tienes los platanos in la bag!")
} else {
print("No platanos in the bag, regresa a por ellos!")
} // else
let friendGroceryBag = Set(["Platanos", "Cereal", "Leche", "Naranjas"])
let combineGroceryBag = groceryBag.union(friendGroceryBag)
print("\nCesta de compras de nuestra amiga: \n")
for food in combineGroceryBag {
print(food)
} // forla salida en pantalla sería:
Nuestra cesta de compras contiene: Piñas Naranjas Manzanas Tenemos ya los platanos? No platanos in the bag, regresa a por ellos! Cesta de compras de nuestra amiga: Cereal Leche Manzanas Platanos Piñas Naranjas
En la línea 23 del anterior código hemos hecho uso del método union(_:) con la intención de unir los dos Set y conformar uno nuevo de nombre combineGroceryBag a partir de groceryBag y friendGroceryBag, conformando este nuevo por los elementos únicos en ambos Sets.
Sustracciones
Otro método de la colección Set que creo merece la pena hacer mencionar sería aquel que nos ayudaría ante la siguiente circunstancia:
Continuemos con la historia anterior, asumamos que cuando llegamos a casa nuestro compañero de cuarto también se dirige hacia el mercado a hacer sus compras y también a comprar frutas ya que este también desea preparar un coctel de frutas.
Dado el hecho de que somos compañeros de cuarto y que nosotros ya hemos comprado varias frutas pues compararemos los productos en común que tiene nuestra lista de compras y la de nuestro amigo, así este solamente tendría que comprar aquellos que no hemos traído.
let roommatesGroceryBag = Set(["Manzanas", "Platanos", "Cereal", "Uvas", "Pasta Dental", "Shampoo"])
let itemsToBuy = roommatesGroceryBag.subtracting(combineGroceryBag)
print("\nNuestro compañero de cuarto solamente tiene que comprar: \n")
for food in itemsToBuy {
print(food)
} // forla salida en pantalla:
Nuestro compañero de cuarto solamente tiene que comprar: Shampoo Uvas Pasta Dental
Para lograr esto último hemos hecho uso de el método substract el cual solamente nos retorna aquellos elementos que no son comunes entre el Set que ejecuta el método y aquel que es pasado como parámetro.
Al igual que Array, Set cuenta con muchos más métodos, muy útiles todos pero imposibles de nombrar aquí, de hacerlo tornarían este tutorial excesivamente largo y aburrido.
Dictionary
Un diccionario almacena asociaciones entre llaves y valores del mismo tipo en una colección sin orden definido. Cada valor está asociado con una clave única, que actúa como un identificador para ese valor dentro del diccionario.
[better-ads type=’banner’ banner=’161′ ]
A diferencia de los elementos de un Array, los elementos de un diccionario no tienen un orden específico. Hacemos uso de un diccionario cuando se necesita buscar valores en función de su identificador, casi de la misma manera que un diccionario en el mundo real cuando buscamos la definición de una palabra en particular.
El tipo de dato Dictionary es bastante útil y por ende bastante usado, su sintaxis es bien sencilla: Dictionary<Key, Value> donde cada campo se estructuraría en la forma [llave tipo: valor tipo], un ejemplo real luciría así:
let someDictionary: [String: Int] = ["David": 32, "Gise": 39]
let otherDictionary: Dictionary<String, Int> = ["David": 32, "Gise": 39]ambas línea son equivalentes.
A los valores de un diccionario se puede acceder a través de subíndices especificando la llave correspondiente entre corchetes: someDictionary [“Gise”] se refiere al valor asociado con la clave “Gise”. El subíndice devuelve un valor asociado a esta llave. Si la clave especificada no está contenida en el diccionario, el subíndice devuelve nil.
Creando e inicializando un Dictionary vacío
En ocaciones es necesario crear e inicializar un diccionario vacio:
var myDictionary: [int: Double] = [:]aquí un ejemplo de un diccionario de llave tipo Int y valores de tipo Double, inicializado con cero elementos. Pero también pudiéramos haberlo logrado de estas otras formas:
var dic1 = Dictionary<String, Double>()
var dic2 = [String : Double]()Accediendo y modificando un Dictionary
Tomando el siguiente diccionario como un ejemplo hipotético para el ejemplo, imaginemos que necesitamos iterar por cada elemento del mismo:
var myDictionary: [Int: Double] = [5: 0.25, 4: 0.20, 3: 0.15, 2: 0.12, 1: 0.10]
for (myKey, myValue) in myDictionary {
print("La llave: \(myKey) cuenta con un valor de: \(myValue)")
} // forla salida en pantalla:
La llave: 5 cuenta con un valor de: 0.25 La llave: 2 cuenta con un valor de: 0.12 La llave: 4 cuenta con un valor de: 0.2 La llave: 3 cuenta con un valor de: 0.15 La llave: 1 cuenta con un valor de: 0.1
En este ejemplo tenemos un bucle de tipo for-in, donde por cada elemento en el diccionario creamos una tupla cuyos tipos de datos son inferidos por el compilador dado el diccionario con el que estemos trabajando.
Modificar el valor de una llave y eliminar la tupla por completo es igual de sencillo:
print("Creamos e iteramos por cada elemento (tupla) del diccionario.")
// Creamos el diccionario
var myDictionary: [Int: Double] = [5: 0.25, 4: 0.20, 3: 0.15, 2: 0.12, 1: 0.10]
// Iteramos por cada elemento (tupla) del mismo
print("")
for (myKey, myValue) in myDictionary {
print("La llave: \(myKey) cuenta con un valor de: \(myValue)")
} // for
print("")
print("Modificamos un valor de la llave 3.")
print("")
// Modificamos un valor de la llave 3
myDictionary[3] = 2.55
for (myKey, myValue) in myDictionary {
print("La llave: \(myKey) cuenta con un valor de: \(myValue)")
} // for
print("")
print("Eliminamos la tupla cuya llave es 3.")
print("")
// Eliminamos la tupla cuya llave es 3
myDictionary[3] = nil
for (myKey, myValue) in myDictionary {
print("La llave: \(myKey) cuenta con un valor de: \(myValue)")
} // forla salida de este código es la siguiente:
Creamos e iteramos por cada elemento (tupla) del diccionario. La llave: 5 cuenta con un valor de: 0.25 La llave: 2 cuenta con un valor de: 0.12 La llave: 4 cuenta con un valor de: 0.2 La llave: 3 cuenta con un valor de: 0.15 La llave: 1 cuenta con un valor de: 0.1 Modificamos un valor de la llave 3. La llave: 5 cuenta con un valor de: 0.25 La llave: 2 cuenta con un valor de: 0.12 La llave: 4 cuenta con un valor de: 0.2 La llave: 3 cuenta con un valor de: 2.55 La llave: 1 cuenta con un valor de: 0.1 Eliminamos la tupla cuya llave es 3. La llave: 5 cuenta con un valor de: 0.25 La llave: 2 cuenta con un valor de: 0.12 La llave: 4 cuenta con un valor de: 0.2 La llave: 1 cuenta con un valor de: 0.1
Creando un Array a partir de un Dictionary
Continuamos por mostrar como pudiéramos crear un arreglo a partir por ejemplo de los nombres de las llaves, veamos:
var myDictionary: [Int: Double] = [5: 0.25, 4: 0.20, 3: 0.15, 2: 0.12, 1: 0.10]
var myKeys = Array(myDictionary.keys)
for key in myKeys {
print("Nombre de la Llave: \(key)")
} // forla salida sería:
Nombre de la Llave: 5 Nombre de la Llave: 2 Nombre de la Llave: 4 Nombre de la Llave: 3 Nombre de la Llave: 1
En este ejemplo tenemos un diccionario del cual extraemos los nombre de sus llaves mediante la propiedad computada de nombre keys, pasando estos datos al constructor de Array el cual retorna una estructura ya inicializada a nuestro arreglo myKeys por el cual luego iteramos sobre cada uno de sus elementos para poder visualizarlos en la salida en pantalla.
Comparativa
Antes de finalizar les dejaré una tabla con una pequeña comparativa entre las colecciones de datos aquí comentadas:
| Tipo de Colección | Ordenadas? | Única? | Almacenamiento |
|---|---|---|---|
| Array | Sí | No | Elementos |
| Dictionary | No | Llaves | Pares de Llave-Valor |
| Set | No | Elementos | Elementos |
a favor de que nos sea más fácil elegir la más adecuada.
Falta aún mucho por aprender en nuestro camino a convertirnos en iOS Developer. Suscríbete a nuestra lista de correo y síguenos en nuestras redes sociales. Mantente al tanto de todas nuestras publicaciones.
Espero que todo cuanto se ha dicho aquí, de una forma u otra le haya servido de aprendizaje, de referencia, que haya valido su preciado tiempo.
Este artículo, al igual que el resto, será revisado con cierta frecuencia en pos de mantener un contenido de calidad y actualizado.
¡Cualquier duda o sugerencia, ya sea errores a corregir o ejemplos a añadir, será más que bienvenida, necesaria!
Buenas! Estoy aprendiendo a programar en el lenguaje Swift. Queria saber como se podria incorporar un array dentro de una tupla. Un ejemplo que estoy tratando de correr es este:
//tupla direccion
typealias Direccion = (calle: [String:String], piso:Int?, departamento: String?, ciudad: String, partido: String,codigoPostal: String?, provincia: String, pais: String)
// Diccionario de Calles
let calle1 : [String:String] = [
«nombreDeCalle» : «illia»,
«numero» : «1875»,
«entrecalle1»: «servantes»,
«entrecalle2»: «lima»
]
let calle2 : [String:String] = [
«nombreDeCalle» : «av. la plata»,
«numero» : «2560»,
«entrecalle1»: «gorriti»,
«entrecalle2»: «alvarez thomas»
]
let calle3 : [String:String] = [
«nombreDeCalle» : «av. triunvirato»,
«numero» : «1843»,
«entrecalle1»: «echeverria»,
«entrecalle2»: «la pampa»
]
// Tres direcciones constantes
let direccion1: Direccion = (calle: calle1, piso:3, departamento: «2A», ciudad: «Calzada», partido: «Almirante Brown», codigoPostal: «1478», provincia: «Buenos Aires», pais: «Argentina») // ESTA PARTE ES LA QUE NO PUEDO ASIGNAR AL COMPONENTE CALLE LA CONSTANTE CALLE1.
/*Escribir una función que reciba una dirección y la imprima como un String bien formateado. Hacer uso de la interpolación.*/
func informacionDireccion(direccion : Direccion) -> String {
var descripcion = «La persona vive en la direccion \(calle.nombreDeCalle) al \(calle.numero) ubicado entre \(calle.entrecalle1) y \(calle.entrecalle2). Dicha direccion se encuentra en la ciudad \(ciudad), partido de \(partido) y su codigo postal es \(codigoPostal) en la provincia de \(provincia), en el pais de \(pais)»;
return descripcion;
}
Queria saber si me podria ayudar con este problema.
Saludos
Hola,
En tu código veo tres errores. El primero es que dentro de la función no haces referencia a la constante local (direccion), el segundo sería que no estás gestionando los valores opcionales de la tupla (el posible valor nil de los mismos) y por último estás intentando acceder al valor de un dictionary haciendo referencia directa al key, dígase:
que en todo caso sería:
ya que no puedes hacer referencia a «calle» sin antes tomar como punto de partida «direccion» que es la tupla que recibe la función como parámetro.
Aquí te dejo el código corregido:
// tupla direccion typealias Direccion = (calle: [String:String], piso:Int?, departamento: String?, ciudad: String, partido: String,codigoPostal: String?, provincia: String, pais: String) // Diccionario de Calles let calle1 : [String:String] = [ "nombreDeCalle" : "illia", "numero" : "1875", "entrecalle1": "servantes", "entrecalle2": "lima"] // Tres direcciones constantes let direccion1: Direccion = (calle: calle1, piso:3, departamento: "2A", ciudad: "Calzada", partido: "Almirante Brown", codigoPostal: "1478", provincia: "Buenos Aires", pais: "Argentina") // ESTA PARTE ES LA QUE NO PUEDO ASIGNAR AL COMPONENTE CALLE LA CONSTANTE CALLE1. /*Escribir una función que reciba una dirección y la imprima como un String bien formateado. Hacer uso de la interpolación.*/ func informacionDireccion(direccion: Direccion) -> String { let nombreCalle = direccion.calle["nombreDeCalle"] ?? "-" let numero = direccion.calle["numero"] ?? "-" let entrecalle1 = direccion.calle["entrecalle1"] ?? "-" let entrecalle2 = direccion.calle["entrecalle2"] ?? "-" let descripcion = "La persona vive en la direccion \(nombreCalle) al \(numero) ubicado entre \(entrecalle1) y \(entrecalle2). Dicha direccion se encuentra en la ciudad \(direccion.ciudad), partido de \(direccion.partido) y su codigo postal es \(direccion.codigoPostal ?? "-") en la provincia de \(direccion.provincia), en el pais de \(direccion.pais)"; return descripcion; } // informacionDireccion print(informacionDireccion(direccion: direccion1))Aún así no es necesario usar tuplas o diccionarios para este ejemplo. Por lo cual el código está lejos de ser el óptimo. Aquí te comparto una alternativa más limpia y mejor estructurada:
import UIKit // Definicion de tipos struct Calle { var nombre: String var numero: String var entreCalle1: String var entreCalle2: String } // Calle struct Address: CustomStringConvertible { var calle: Calle var piso: String? // Si no vas a hacer calculos con con este valor numérico mejor que sea de tipo String var departamento: String? var ciudad: String var partido: String var codigoPostal: String? var provincia: String var pais: String var description: String { let structDescription = """ La persona vive en la calle \(calle.nombre), número \(calle.numero) piso \(piso ?? "-"), ubicado entre \(calle.entreCalle1) y \(calle.entreCalle2). Dicha dirección se encuentra en la ciudad \(ciudad), partido \(partido) y su codigo postal es \(codigoPostal ?? "-"), provincia de \(provincia), \(pais). """ return structDescription; } // description } // Address // Declaración de las instancias let miCalle = Calle(nombre: "Ilia", numero: "1875", entreCalle1: "Servantes", entreCalle2: "Lima") let miDireccion = Address(calle: miCalle, piso: "3", departamento: "2A", ciudad: "Calzada", partido: "Almirante Brown", codigoPostal: "1478", provincia: "Buenos Aires", pais: "Argentina") // Imprimir con formato los datos almacenados en la estructura miDireccion print(miDireccion)Este ejemplo lo puedes correr en un Playground. Espero te resulte útil.
Saludos! 👋