Control Flow: FOR, WHILE, IF, GUARD, SWITCH en Swift en Español

Swift nos provee de varios controles de flujo. Podemos usar while, if, guard, switch, for, etc

Son útiles para añadir lógica en nuestros programas, por ejemplo, si A > B quiero que se aplique la lógica X (if, guard). Para distintos estados quiero que me ejecutes una instrucción (switch), o mientras tenga la 'condición X' quiero que ejecutes otra lógica (while, for), etc.

Bucles For-In en Swift

Se usa for-in para iterar dentro de una secuencia, como por ejemplo los items de un array, caracteres en un string, etc

let names = ["Swift", "Beta", "Blog"]
for name in names {
    print("Hello, \(name)!")
}

También puedes iterar dentro de un dictionary de la siguiente manera:

let namesWithNumber = [10: "Swift", 20: "Beta", 30: "Blog"]
for (number, name) in namesWithNumber {
    print("Number \(number) and Name \(name)")
}

Y también podemos iterar rangos de valores, si queremos iterar del 1 al 5 incluido podemos usar el siguiente snippet de código:

for index in 1...5 {
    print("Index \(index)")
}

Bucles While en Swift

Cuando usamos un while, dentro de su scope ocurre cierta lógica y hasta que la condición del while no es false seguimos iterando dentro de él.

var count = 0
while count < 10 {
    print("Count \(count)")
    count += 1
}

En este caso hemos printado el valor de count 10 veces, y como 10 < 10 es false, se ha cerrado el bucle.

Sentencias condicionales en Swift

If en Swift

Usamos if para ejecutar condiciones muy simples, si se cumple la condición entramos dentro de su scope y ejecutamos cierta lógica.

Una forma de entender que es un scope es desde que se abre una llave curva hasta que se cierra. Ejemplo: clases, structs, funciones, dentro de ifs, etc.
if { scope }
for { scope }

var numberOfSubscribers = 100

if numberOfSubscribers > 10 {
    print("A bunch of subscribers! 🤓")
}

Si la condición no se cumple y queremos ejecutar otra lógica, podemos añadir un else

var numberOfSubscribers = 100

if numberOfSubscribers > 10 {
    print("A bunch of subscribers! 🤓")
} else {
    print("Keep working!")
}

También y como en otros lenguajes de programación podemos añadir varios else if

var numberOfSubscribers = 100

if numberOfSubscribers > 10 {
    print("A bunch of subscribers! 🤓")
} else if numberOfSubscribers > 5 {
    print("We need more subscribers!")
} else {
    print("Keep working!")
}

Guard en Swift

Los guard son un early return, nos ayudan a salir del scope cuando no se cumple una condición. Son muy parecidos a un if.

var myArray: [String] = []

func checkMyArray() {
    guard !myArray.isEmpty else {
        print("Array is empty!")
        return
    }
    
    print("Array is NOT empty!")
}

checkMyArray()

// El resultado será "Array is empty!"

Otra funcionalidad de los guard es que podemos extraer el valor de un opcional. Es decir, lo mismo que hacíamos con un if let x = opcional { }

var myOptional: Int? = 2

func checkMyOptional() {
    guard let value = myOptional else {
        print("myOptional is nil!")
        return
    }
    
    print("myOptional value is \(value)!")
}

checkMyOptional()

// El resultado será "myOptional value is 2!"

Opcionales en Swift

Una de las ventajas de Swift es el uso de opcionales. Por eso en este post te hago una breve introducción para que empieces a usarlos.

SwiftBetaSwiftBeta

Switch en Swift

Los switch son realmente útiles cuando tenemos un valor y lo comparamos con distintos casos. Si se cumple la condición se ejecuta esa lógica, el funcionamiento es parecido a de los if pero mucho más potente.

var numberOfSubscribers = 100

switch numberOfSubscribers {
case 100:
    print("A bunch of subscribers! 🤓")
default:
    print("Keep working!")
}

Tenemos que añadir un default porque en caso de no entrar en ningún case entraría en éste último.

Podemos vitaminar nuestro switch añadiendo where

var numberOfSubscribers = 100

switch numberOfSubscribers {
case let x where numberOfSubscribers > 5:
    print("A bunch of subscribers! TOTAL: \(x)")
default:
    print("Keep working!")
}

En este caso debe cumplir la condición del where para poder entrar dentro del primer case. Podemos coger el valor exacto de x y manipularlo dentro del scope como queramos.

Los switch son muy útiles cuando usamos enums, imagina que tenemos un enum que representa los distintos estados de un mensaje de whatsapp:

enum MessageStatus {
    case sent
    case delivered
    case read
}

Para aplicar una lógica para cada estado, podemos usar un switch:

let status: MessageStatus = .read

switch status {
case .sent:
    print("Message sent, add grey stick")
case .delivered:
    print("Message delivered, add new stick")
case .read:
    print("Message read, update double stick to blue")
}

En este caso no necesitamos añadir el default ya que estamos cubriendo todos los casos del enum.