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.
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.
//iteración sobre un array
let array = ["Uno", "Dos", "Tres"]
for item in array {
print("Hola \(item)")
}
//Devuelve:
//Hola Uno
//Hola Dos
//Hola Tres
//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
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:
for numero in 1...4 {
print(numero)
}
//Devuelve
//1
//2
//3
//4
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 “Dos” y “Tres” 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:)
for numero in stride(from: 0, through: 10, by: 2) {
print(numero)
}
//Devuelve:
//0
//2
//4
//6
//8
//10
Si quisiéramos hacer lo mismo pero sin incluir el 10, podemos usar stride(from:to:by:)
for numero in stride(from: 0, to: 10, by: 2) {
print(numero)
}
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:
while condición {
sentencias
}
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
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:
repeat {
sentencias
} while condición
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
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.
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.
let promedio = 9
if promedio >= 7 {
print("Curso aprobado!")
}
//Devuelve:
//Curso aprobado!
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.
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!
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:
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
}
Como se puede observar, primero se define un valor determinado que luego se va a comparar con otros valores, dentro de cada case. La gran ventaja de Swift es que en cada case no solamente se pueden utilizar 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.
let personajeAnime = "Goku"
switch personajeAnime {
case "Goku":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}
//Devuelve:
//Kamehameha!!
En el ejemplo, se crea un personaje de Anime y se pregunta en cada casepor 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:
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
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:
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!!
Como vemos, fallthrough hace que al terminar de ejecutar ese casesiga 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:
let nota = 5
switch nota {
case 0…6:
print("Examen desaprobado")
case 7…10:
print("Examen aprobado")
default:
print("Nota inexistente")
}
//Devuelve:
//Examen desaprobado
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.
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
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:
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
Ejemplos completos
//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
for numero in 1...4{
print(numero)
}
//Devuelve
//1
//2
//3
//4
for numero in stride(from: 0, through: 10, by: 2) {
print(numero)
}
//Devuelve:
//0
//2
//4
//6
//8
//10
for numero in stride(from: 0, to: 10, by: 2) {
print(numero)
}
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
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
let promedio = 9
if promedio >= 7 {
print("Curso aprobado!")
}
//Devuelve:
//Curso aprobado!
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!
let personajeAnime = "Goku"
switch personajeAnime {
case "Goku":
print("Kamehameha!!")
case "Vegeta":
print("Final Flash!!")
default:
print("nada")
}
//Devuelve:
//Kamehameha!!
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!!
let nota = 5
switch nota {
case 0...6:
print("Examen desaprobado")
case 7...10:
print("Examen aprobado")
default:
print("Nota inexistente")
}
//Devuelve:
//Examen desaprobado
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