Home » Cursos » Swift 2 Lección 5, Tuplas
Swift Lección 5

Swift 2 Lección 5, Tuplas

Compra "Aprendiendo Swift 3"

La presente lección está probada y certificada en su funcionamiento con la versión 7 o superior de Xcode y corresponde a la especificación 2 y 2.1 del lenguaje Swift.
Volvemos con una nueva lección del curso de Swift, hablando sobre otra interesante funcionalidad de las que incorpora el lenguaje: las tuplas o tuples en inglés.

¿Qué es este tipo de dato? En realidad es la agrupación de varios tipos de datos, complejos o no, dentro de un mismo tipo. Lo más importante de las tuplas no es tanto cómo funcionan por sí solas, si no lo importantes que son al formar parte del sistema en tareas esenciales.

Vamos a suponer que queremos almacenar bajo un mismo tipo el nombre de una película y su año de estreno. Usando la inferencia de datos podríamos hacerlo de una manera tan sencilla como esta:

Vamos a fijarnos en la evaluación de la expresión que nos da el playground.

Tuples Ejemplo 1

Pone (.0 "Interstellar", .1 2,014). ¿Qué significa esto? Pues que no solo ha creado nuestra variable film como una tupla con valores múltiples, sino que les ha asignado un índice a cada uno de manera automática: 0 y 1. Vamos a evaluar entonces film de la siguiente manera, accediendo a estos índices como si fueran métodos de la variable:

La primera opción nos muestra ambos valores separados por una coma y la segunda y tercera nos permite acceder a los valores por separado usando el auto-índice 0 y 1. Si queremos cambiar un valor, solo tenemos que asignar uno nuevo al valor del índice directamente.

Cambiamos el nombre de la película y al volver a evaluar los valores, vemos el cambio. Así de simple, siempre teniendo mucho cuidado de no acceder a valores de índice que no existen, pues provocaría un error fatal y la salida de la app.

Una cosa que nos puede resultar muy cómoda es nombrar los componentes para no tener que recordar el orden en que fueron puestos a la hora de declarar. Por ejemplo, vamos a volver a crear nuestra tupla:

Hemos puesto un nombre a cada valor, pero vemos que la evaluación en nuestro playground no cambia y sigue indicando el 0 y el 1. Cuando evaluamos los componentes por separado hace exactamente igual: 0 y 1. Pero nos damos cuenta de un cambio: al escribir film. se nos despliega la posibilidad de elegir uno de los componentes por su nombre como si fueran métodos de la variable.

Tuples Ejemplo 02

Ahora podemos referirnos a nuestros componentes por su nombre. También puede ser que nos interese que year no tenga por qué ser Int que es como la inferencia ha decidido que sea. Puede que nos interese que sea Double o meter una puntuación que sea flotante. Por lo tanto, podemos especificar los tipos en la declaración.

Para hacer esto debemos poner las descripciones, no donde dábamos valor a los componentes, sino trasladamos estas a la parte donde designamos el tipo de dato:

Una función muy interesante de una tupla, es su deconstrucción. Podemos hacer que cada valor vaya a una variable diferente:

Esta sencilla instrucción nos crea e inicializa tres constantes que recogen el valor de cada uno de los componentes de la tupla por orden de índice.

De hecho, hay una forma muy interesante de usar esta función y que ya vimos en una ejemplo de la anterior lección sobre funciones: la enumeración de arrays. En aquel ejemplo creábamos una función cuyo bucle for in era for (index, cadena) in cadenas.enumerate(). Esto no es más que la deconstrucción de una tupla, ya que internamente un array almacena cada registro de sí mismo como una, donde podemos nombrar a cada elemento de la misma para luego recuperar su valor según su orden.

Si quisiéramos sacar solo un valor de la tupla, podríamos hacerlo obviando el resto con el operador _ que nos permite crear un placeholder o tipo vacío que el compilador ignorará.

De esta forma, estamos ignorando los otros dos valores de la tupla y creando solo una constante pelicula que almacena el valor que corresponde al índice de film.

Usos prácticos

Como hemos dicho al principio, lo realmente importante de las tuplas no es cómo funcionen o no, si no las aplicaciones que tienen a través de todo el lenguaje dada su alto nivel de integración en este. Su uso puede facilitarnos la vida, sobre todo si hacemos un uso indirecto de las mismas.

Imaginemos que queremos declarar varias variables a la vez y darles un valor, como por ejemplo, las coordenadas en un espacio tridimensional x, y y z. Normalmente haríamos:

Con ayuda de las tuplas, podemos reducir el código así:

Vamos a ver, como ya hemos visto antes, el caso de las enumeraciones. Podemos enumerar tanto arrays como diccionarios a través de tuplas, pudiendo acceder a cada elemento de manera individual a través del índice. Por ejemplo, con un diccionario declarado así:

Podíamos recorrerlo de dos maneras, una deconstruyendo la tupla y la otra usando el valor en sí de la propia tupla interna.

En el primer ejemplo, con solo indicar el nombre que queramos usar en el for in, el sistema se encargará de poner la tupla del diccionario directamente a nuestro servicio. O bien, con el segundo ejemplo, podemos deconstruir la misma en sus valores por separado, dándoles el nombre que queramos, y así poder realizar una rápida enumeración.

En el caso de los arrays, como ya hemos visto, es igual de fácil:

Otra opción muy interesante es con los switch, el interesante control de flujo que vimos en la lección 2 del curso. Usando este, podemos validar varios valores a la vez e incluso que uno de ambos coincida con lo que buscamos.

Vamos a ver un ejemplo más complejo para ver cómo podríamos aplicar este uso. Imaginemos que tenemos un objeto en pantalla cuya posición es una tupla que contiene los valores x e y (posición 0 y 1). Esta posición se llama coordenada y en principio vamos a darle un valor de (100,100). Pero si vamos cambiando los valores veremos cómo la cosa cambia. Y vamos a suponer que tenemos un centro que queremos controlar y que lo vamos a situar en la posición (160,100).

La primera opción es clara: saltará cuando el objeto esté en el punto (0,0). La segunda (0,_) indica que cualquiera que sea el valor de y (por eso usa el _), si la x es nos dirá que está pegado a la izquierda. La siguiente, controla si está abajo del todo: para cualquier valor x (o .0) si la y (o .1) es está pegado abajo del todo. En la siguiente condición deconstruimos la tupla en dos constantes x e y y luego indicamos en el case que valide esta opción donde x e y sean iguales, lo que indicaría que nuestro elemento está en la diagonal de la pantalla.

En el siguiente, volvemos a deconstruir la tupla en x e y y preguntamos donde x sea igual al índice de la tupla coordenada e y sea igual al índice 1. Y en el último hacemos uso de los rangos de Swift: desde el valor de centro.0-2 hasta el mismo valor centro.0+2 y desde el valor de centro.1-2 hasta el mismo centro.1+2, de forma que si los valores y 1 de la tupla coinciden en estos rangos sabemos que está cerca del centro.

La última posible función la vimos también en la anterior lección con las funciones. Si recordamos cómo se enviaban varios valores de vuelta en una función, la respuesta es con las tuplas. Recordamos los ejemplos que dábamos para devolver varios valores a la vez:

Lo que usábamos para devolver varios valores de una función era una tupla, en la que incluso podíamos nombrar los valores y acceder a los componentes por dicho nombre como hemos visto en los primeros ejemplos.

Conclusiones

Las tuplas es un tipo de dato compuesto que es una de las grandes novedades que incorporó Swift, y cuyo mayor valor no es el tipo en sí, si no que está muy integrado en el sistema y por lo tanto podemos sacarle un gran rendimiento.

Como siempre, os instamos a que probéis, experimentéis y le saquéis todo el jugo a cada una de las lecciones, y os emplazamos para la próxima lección. También podéis ver mientras, si no lo habéis visto aun, la primera lección del curso de apps que seguro os resultará útil y complementario a este otro de Swift.

Un saludo a todos y como siempre Good Apple Coding.

Compra "Aprendiendo Swift 3"

Acerca de Julio César Fernández

Analista, consultor y periodista tecnológico, desarrollador, empresario, productor audiovisual, actor de doblaje e ingeniero de vídeo y audio.

Otras recomendaciones

Lecciones Prototipos (I): UITableView

Lecciones por prototipos (I): Vistas de tabla (UITableView)

Primera lección por prototipos, un nuevo e innovador contenido. A veces, lo normal es que nos perdamos sin terminar de entender qué es o cómo funcionan los componentes que forman parte de una app o un juego. Para este caso hemos creado las lecciones por prototipos. Una exploración básica de conceptos esenciales a través de prototipos en Playground que podemos probar con Swift Playgrounds en el iPad o con Xcode 8. En esta primera lección abordamos las UITableView (vistas de tabla). Un elemento esencial en la mayoría de apps de iOS que muchas veces no es entendido desde su base y por lo tanto, provoca un mal uso de las mismas.