Control de flujo en Swift

Control de flujo

Uno de los temas que conforman el ABC del aprendizaje de un lenguaje de programación es sin dudas el del control de flujo. Esto refiere a unos comandos que podemos usar para modificar el orden secuencial de un programa, permitiéndoles saltarse líneas, ejecutar varias veces una misma sentencia, hacer decisiones en base a condiciones, etcétera.

Control de flujo 1 – Bucles

Los bucles o loops nos permiten ejecutar un algoritmo una cierta cantidad de veces, dependiendo de la condición que se utilice o el rango de inicio y fin.

For-in

Básicamente existen dos escenarios donde podemos usar este tipo de bucles. El primero se da cuando se necesita recorrer una colección de ítems, como es el caso de un array o un diccionario.

[code lang=”Swift”]
//iteración sobre un arreglo
let array = ["Mundo", "Gabriel", "Vecino"]

for item in array {
print("Hola \(item)")
}

//Devuelve:
//Hola Mundo
//Hola Gabriel
//Hola Vecino

//Iteración sobre un diccionario
let stock = ["Mouse": 5, "Teclado":20, "Pen drive": 10]

for (dispositivo, cantidad) in stock {
print("Se disponen de \(cantidad) unidades de \(dispositivo)")
}

//Devuelve:
//Se disponen de 5 unidades de Mouse
//Se disponen de 20 unidades de Teclado
//Se disponen de 10 unidades de Pen drive
[/code]

Como se puede apreciar, al recorrer un diccionario se obtiene, en cada iteración, una tupla (dispositivo, cantidad) al que luego se puede acceder haciendo referencia a sus nombres y solo existe mientras dure el ciclo del for.

El otro escenario donde se usa este tipo de loop se da cuando se conoce el rango sobre el cual se quiere iterar. Por ejemplo, si quisiéramos contar desde 1 a 4 podríamos hacer:

[code lang=”Swift”]
for numero in 1…4 {
print(numero)
}

//Devuelve
//1
//2
//3
//4
[/code]

En cada ejecución del bucle, la constante numero va tomando los valores del rango, empezando por 1 y terminando por 4. En el ejemplo, se está usando el operador de rango cerrado (…) que implica que se incluye en el rango tanto el 1 como el 4.

Operadores de rango

Como te estarás imaginando, ese no es el único tipo de operador de rango que existe, sino que podemos optar por los siguientes:

  • Operador de rango cerrado (…): es el que ya vimos. Incluye los bordes.
  • Operador de rango semi abierto (..<): incluye el rango de inicio pero excluye el final. Por ejemplo, 1..<4 toma los valores 1, 2 y 3.
  • Operador de rango a un lado (n…): se llama así ya que permite indicar el numero de posición del elemento desde el que se quiere iterar hacia delante lo más posible. Si tomamos el ejemplo del primer array y usamos un rango de (1…) se incluirían los valores “Gabriel” y “Vecino” ya que se está indicando que se comience por el valor de la posición 1. Recordemos que los array comienzan en el índice 0. De la misma manera, se pueden hacer rangos a un lado a la inversa (…n) para indicar que se quiere iterar desde el primer valor hasta la posición n.
  • Operador de rango semi abierto a un lado (..<n): es la combinación de los dos anteriores. Se especifica desde o hasta donde queremos iterar (a un lado) pero dejando el borde abierto.

Stride

Existe una manera especial de indicar rangos en la que se permite “saltearse” valores. Por ejemplo, si quisiéramos contar de 2 en 2 desde 0 a 10 podemos usar stride(from:through:by:)

[code lang=”Swift”]
for numero in stride(from: 0, through: 10, by: 2) {
print(numero)
}

//Devuelve:
//0
//2
//4
//6
//8
//10
[/code]

Si quisiéramos hacer lo mismo pero sin incluir el 10, podemos usar stride(from:to:by:)

[code lang=”Swift”]
for numero in stride(from: 0, to: 10, by: 2) {
print(numero)
}
[/code]

While

Este tipo de bucle realiza iteraciones hasta que una condición dada devuelva false. Existen dos tipos:

While

Primero se chequea la condición. Si la misma devuelve true, se accede al bucle. La sintaxis es la siguiente:

[code lang=”Swift”]
while condición {
sentencias
}
[/code]

[code lang=”Swift”]
var contador = 0

while contador < 10 {
print("Contador: \(contador)")
contador += 1
}

//Devuelve:
//Contador: 0
//Contador: 1
//Contador: 2
//Contador: 3
//Contador: 4
//Contador: 5
//Contador: 6
//Contador: 7
//Contador: 8
//Contador: 9
[/code]

En el ejemplo anterior, se define un contador con un valor inicial de 0. Luego se repiten dos sentencias (se imprime por pantalla el valor del contador y se lo incrementa en 1) siempre que ese contador sea menor a 10. Por lo tanto, el bucle va a ejecutarse hasta que el contador llegue al valor 9. Una vez que valga 10, no va a cumplir la condición del while y por lo tanto no va a volver a ingresar.

Repeat – while

Primero se realiza una iteración del bucle y luego se chequea la condición. Si la misma devuelve true, vuelve a ejecutar el bucle hasta que la condición sea false. Este bucle se utiliza cuando se sabe que por lo menos una vez es necesario ejecutar el algoritmo que contiene. La sintaxis es la siguiente:

[code lang=”Swift”]
repeat {
sentencias
} while condición
[/code]

[code lang=”Swift”]
contador = 0

repeat {
print("Contador: \(contador)")
contador += 1
} while contador < 10

//Devuelve:
//Contador: 0
//Contador: 1
//Contador: 2
//Contador: 3
//Contador: 4
//Contador: 5
//Contador: 6
//Contador: 7
//Contador: 8
//Contador: 9
[/code]

Aquí se vuelve a inicializar el contador a 0 y a continuación ya se ejecuta el primer ciclo del bucle, en donde se realizan las dos mismas operaciones que en el ejemplo anterior. La diferencia radica en que en este caso siempre se ejecuta por lo menos una vez el bucle, mientras que en el ejemplo del while solo se ingresa si cumple la condición inicial.

Control de flujo 2 -Sentencias condicionales

Este tipo de sentencias nos permiten tomar decisiones a lo largo del programa y ejecutar determinadas líneas de código siempre que se cumpla alguna condición. Existen dos sentencias para ello: if y switch.

If

Esta sentencia se usa para las condiciones más simples que poseen pocas opciones.

[code lang=”Swift”]
let promedio = 9

if promedio >= 7 {
print("Curso aprobado!")
}

//Devuelve:
//Curso aprobado!
[/code]

En este ejemplo se valida si la constante promedio es mayor o igual a 7. En ese caso se imprime “Curso aprobado!” y en caso contrario no se está realizando ninguna acción.

Asimismo, se pueden anidar varios if en caso de necesitar preguntar por nuevas condiciones.

[code lang=”Swift”]
let alumnos = 20

if alumnos < 10 {
print("Hoy faltaron muchos alumnos")
} else if alumnos < 17 {
print("Vinieron muchos alumnos")
} else {
print("Hoy vinieron todos!")
}

//Devuelve:
//Hoy vinieron todos!
[/code]

En este ejemplo, se crea una constante con la cantidad de alumnos que vinieron a clase y se le asigna un 20. Luego se pregunta si vinieron menos de 10 alumnos y en caso de ser cierto, se imprime “Hoy faltaron muchos alumnos”. En caso de que esa condición no sea cierta (o sea, si el valor es igual o mayor a 10) se pasa a la segunda condición, donde solo ingresaría si el valor es menor a 17. Como tampoco es correcto, ingresa al else el cual se ejecuta en cualquier otro caso. Como ninguno de los condicionantes anteriores devolvieron true, ya que la cantidad de alumnos es 20, se imprime por pantalla “Hoy vinieron todos!”.

Si bien se pueden anidar varios else-if, no resulta práctico si se tienen muchas condiciones que validar. En ese caso, conviene considerar la posibilidad de usar switch.

Switch

Esta sentencia resulta práctica cuando se tienen que validar una gran cantidad de condiciones. Switch compara un determinado valor con una serie de opciones y en caso de validar alguna o algunas de ellas, se ejecuta el código que la misma contiene.

El uso de esta sentencia en Swift es realmente muy poderoso ya que en cada opción se puede hacer uso de varios patrones y no solamente valores constantes como en otros lenguajes de programación.

La sintaxis de este comando es:

[code lang=”Swift”]
switch valor a considerar {
case valor 1:
sentencias para el valor 1
case valor 2,
valor 3:
sentencias para el valor 2 y 3
default:
caso contrario, hacer otra cosa
}
[/code]

Como se puede observar, primero se define un valor determinado que luego se lo va a comparar con otros valores, dentro de cada case. La potencia que mencionamos anteriormente es que en cada case no solamente se pueden poner valores constantes sino que existe una gran cantidad de patrones que podemos usar, lo cual genera una gran flexibilidad en nuestro código.

Una vez que alguno de los case coincide o “hace match” con el valor comparado, se ejecuta el bloque que el mismo encierra, de la misma manera que sucede con el if.

Un punto a tener en cuenta es que la sentencia switch debe ser exhaustiva. Esto implica que dado un valor a considerar, se deben especificar dentro de los case todos los casos posibles que ese valor puede llegar a tener. En los casos en los que no es posible hacerlo o el programador no tiene intenciones de dar un comportamiento en particular para algún valor determinado, se puede usar la palabra reservada default. Al hacer uso de éste se cubren todos los demás casos no especificados en cada case.

A diferencia de otros lenguajes, no se debe usar break al final de cada case, ya que al ingresar a uno se ejecutan las líneas de código que este contiene y se sale del switch automáticamente.

[code lang=”Swift”]
let personajeAnime = "Goku"

switch personajeAnime {
case "Goku":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}

//Devuelve:
//Kamehameha!!
[/code]

En el ejemplo, se crea un personaje de Animé y se pregunta en cada case por un personaje en particular. Como el primer case es el que valida la sentencia switch, se ejecuta el print y se devuelve “Kamehameha!!”. Es importante destacar que la sentencia default es obligatorio ponerlo ya que si la constante personajeAnime no vale ni Goku ni Vegeta no se sabría que hacer (definición de exhaustivo). Siempre es obligación cubrir todos los valores posibles.

Fallthrough

Otro punto a tener en cuenta es que cada case debe tener un bloque de ejecución (no puede estar vacío y no contener sentencias en su interior). El siguiente switch no es correcto:

[code lang=”Swift”]
switch personajeAnime {
case "Goku":
case "Gohan":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}

//Devuelve el error:
//error: ‘case’ label in a ‘switch’ should have at least one executable statement
[/code]

En su lugar, se pueden poner dos valores distintos en el mismo case, separado por una coma o usar la palabra fallthrough en el primero de ellos:

[code lang=”Swift”]
switch personajeAnime {
case "Goku":
fallthrough
case "Gohan":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}

//Devuelve:
//Kamehameha!!

switch personajeAnime {
case "Goku", "Gohan":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}

//Devuelve:
//Kamehameha!!
[/code]

Como vemos, fallthrough hace que al terminar de ejecutar ese case siga ejecutando el case siguiente.

Comparación por intervalos.

En el caso de tener que tomar una acción determinada dependiendo de un valor numérico en el switch, se pueden usar rangos para agrupar acciones dentro de un mismo case. De esta forma, suponiendo que se debe construir un algoritmo que indique si un examen se encuentra aprobado o desaprobado, se puede utilizar las siguientes líneas:

[code lang=”Swift”]
let nota = 5

switch nota {
case 0…6:
print("Examen desaprobado")
case 7…10:
print("Examen aprobado")
default:
print("Nota inexistente")
}

//Devuelve:
//Examen desaprobado
[/code]

En el ejemplo anterior se utilizan rangos para agrupar las notas comprendidas entre 0 y 6 por un lado, y de 7 a 10 por otro lado. En ambos casos, los extremos del rango están incluidos en el case. Por último, dado que la sentencia switch debe ser completa, es obligatorio el uso del default para cualquier nota menor a 0 o mayor a 10, algo que en la práctica no debería ser posible. Cabe aclarar que cualquier operador de rango visto anteriormente puede ser usado dentro del case.

Vinculación de valores y where

La sentencia switch permite crear constantes o variables temporales en cada case para poder usar el valor que se está comparando dentro del cuerpo de ese case, en caso de entrar al mismo. Esta técnica es conocida como value binding (vinculación de valores). Asimismo, se puede utilizar la sentencia where para agregar condiciones adicionales y hacer más específica la comparación de ese case.

[code lang=”Swift”]
let numero = 18

switch numero {
case let x where x%2 == 0:
print("Número par: \(x)")
case let x where x%2 != 0:
print("Número impar:\(x)")
default:
print("Nada")
}

//Devuelve:
//Número par: 18
[/code]

En el ejemplo, se crea una constante numero y se le asigna el valor 18. Luego en el primer case se pregunta en el where si ese valor es divisible por 2 para comprobar si es par y en el segundo case, si es impar. En ambos casos, se crea una constante x para almacenar ese valor y luego imprimirlo usando print. Como el numero es par, se obtiene como resultado “Número par: 18”.

Break

Como dijimos anteriormente, la sentencia switch debe ser exhaustiva, por lo tanto todos los casos posibles deben ser cubiertos por los case. Sin embargo, en muchas ocasiones no hay necesidad de tomar alguna acción en algunos case y para esto es muy útil la sentencia break. En otras palabras, break nos permite terminar la ejecución del switch para que el flujo del programa continue inmediatamente luego de éste. Se puede decir que ésta es la manera en la que Swift nos permite ignorar determinados case.

De esta manera, una forma más elegante de escribir el código anterior es:

[code lang=”Swift”]
let numero = 18

switch numero {
case let x where x%2 == 0:
print("Número par: \(x)")
case let x where x%2 != 0:
print("Número impar:\(x)")
default:
break
}

//Devuelve:
//Número par: 18
[/code]

Descarga el archivo playground.
Siguiente capítulo: Opcionales.

Si quieres aprender más sobre que es iOS sigue este enlace con una guía definitiva sobre el mejor Sistema Operativo para móviles.
¿Te ha gustado este artículo?
Control de flujo en Swift Overall rating: ★★★★★ 4.9 based on 11 reviews
5 1

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *