Ciclos o bucles en Swift: for in, while y repeat-while

Hoy vamos a hablar sobre otro de los elementos básicos en cualquier lenguaje de programación, como son los ciclos o también llamados bucles que como debes de saber permite ejecutar un número determinado de veces un grupo de iteraciones sobre un bloque de código, y este número de repeticiones viene establecida o marcada por una condición al estilo de los condicionales en Swift que tratamos en la entrada anterior.

Cuando empiezas a programar en Swift, uno de los primeros conceptos que necesitas dominar sí o sí son los ciclos o bucles. Son una pieza clave del flujo de control y te permiten ejecutar un mismo bloque de código varias veces, ya sea un número concreto de iteraciones o hasta que se cumpla una condición.

En mi caso, entender bien los bucles desde el principio me ahorró muchos errores típicos y me ayudó a escribir código más limpio y fácil de mantener. En este artículo vamos a ver los bucles en Swift más importantes —for-in, while y repeat-while— con ejemplos claros y prácticos.

¿Qué son los ciclos o bucles en Swift y para qué sirven?

Los ciclos o bucles en Swift permiten repetir un conjunto de instrucciones sin tener que escribir el mismo código una y otra vez. Esto es fundamental para:

• Recorrer arrays y colecciones
• Procesar rangos de valores
• Repetir tareas hasta que se cumpla una condición
• Controlar el flujo de un programa de forma eficiente

Swift incluye varios tipos de bucles, cada uno pensado para un escenario concreto. Elegir el adecuado marca la diferencia entre un código claro y uno difícil de entender.

Tipos de bucles en Swift

En Swift trabajamos principalmente con tres tipos de bucles:

• for-in
• while
• repeat-while

Vamos a verlos uno a uno.

Aunque como vamos a ver, cada uno de ellos tienen su variación que vamos a tratar a continuación:

El bucle for-in en Swift

Existen muchísimas variaciones que puedes aplicar sobre un bucle de tipo for, generalmente todas van seguidas del in que acto seguido permite que especifiquemos el tipo de estructura que podemos iterar, que pueden ser desde rangos hasta array todas con sus variaciones y con posibilidad de combinar todos los esquemas que te traemos aquí; recuerda que te presentamos los esquemas más comunes pero existen más.

El bucle se podría ver como el más sencillo de entender, ya que viene con una estructura bien marcada y fácil de entender; en el mismo especificamos la cantidad de interacciones que queremos realizar, marcando el elemento inicial y luego el elemento final y aumentando de uno en uno de manera por defecto:

for i in 1...5 {
    print(i)
}

Aquí obtenemos como salida:

12345

Usar for-in con rangos numéricos

Swift ofrece operadores de rango muy potentes:

• ... → rango cerrado (incluye ambos extremos)
• ..< → rango semiabierto (excluye el valor final)

En el ejemplo anterior mostramos una variable llamada i que toma como primera valor el de uno, ya que ese es el primer valor del rango 1..5, y a medida que se ejecuta este valor se va incrementando en uno hasta llegar al final del rango que para este ejemplo sería el de 5.

En el mismo podemos colocar cualquier tipo de lógica que queramos, por ejemplo, si queremos hacer una distinción entre valores pares e impares:

for i in 1...10 {
    if i%2 == 0{
        print("Es par \(i)")
    } else {
        print("Es impar \(i)")
    }
}

El resultado sería:

Es impar 1
Es par 2
Es impar 3
Es par 4
Es impar 5
Es par 6
Es impar 7
Es par 8
Es impar 9
Es par 10

Esta es la estructura que tenemos por defecto y usualmente se emplea para iterar colecciones como lo son listas o arrays.

For in y los where

Ahora, supongamos que tenemos una lista o un rango muy grande, y solo queremos procesar algunos y no toda la colección para economizar recursos de computo, según un condicional como explicamos en la entrada anterior, entonces; ¿Cómo hacemos para que el for solo se ejecute en base a una condición?; para eso podemos emplear la estructura del where como vemos a continuación en donde solo se van a mostrar los valores pares:

for i in 1...10 where i % 2 == 0{
    print("Es par \(i)")
}

El resultado sería:

Es par 2
Es par 4
Es par 6
Es par 8
Es par 10

Como puedes ver, simplemente incorporamos una estructura condicional, tal cual explicamos en el vídeo anterior.

Bucles for en orden inverso y valores personalizados (reversed y stride)

Ahora, supongamos que nos interesa procesar una lista al revés, aunque esto es una función de los rangos, es importante conocer que también podemos hacer esta clase de definiciones cuando estamos creando un for en Swift:

for i in (1...5).reversed(){
    print("Val  \(i)")
}

El resultado sería:

Val 5
Val 4
Val 3
Val 2
Val 1

Y si necesitas incrementos personalizados, puedes usar stride:

for i in stride(from: 0, to: 10, by: 2) {
   print("Val \(i)")
}

O incluso recorrer valores decrecientes:

for i in stride(from: 5, to: 0, by: -1) {
   print("Val \(i)")
}

Estas opciones son muy potentes y evitan lógica extra dentro del bucle.

For in valores decrecientes

Si queremos ir de mayor a menor, podemos implementar una estructura como la siguiente en la cual vamos decrementando valores desde el 5 hasta el 1:

for i in stride(from: 5, to: 0, by: -1) {
    print("Val \(i)")
}

El resultado sería:

Val 5
Val 4
Val 3
Val 2
Val 1

For in incrementar en valores personalizados

También podemos personalizar en cuanto va a incrementar o decrementar nuestra variable empleando la función stride de la siguiente forma:

for i in stride(from: 0, to: 10, by: 2) {
    print("Val \(i)")
}

El resultado sería:

Val 0
Val 2
Val 4
Val 6
Val 8

Recorrer arrays con los for in

Como indicamos al inicio de la entrada, el uso más común que le podemos dar a los for, es que iteren un objeto de tipo lista o array como presentamos en el siguiente caso:

let numeros = [5, 10, 15, 20, 25, 30, 100]

for i in numeros {
    print("Val \(i)")
}

También podemos variar su implementación de la siguiente forma:

numeros.forEach { i in
    print("Val \(i)")
}

El resultado sería:

Val 5
Val 10
Val 15
Val 20
Val 25
Val 30
Val 100

For-in con condiciones usando where

Cuando trabajas con colecciones grandes, no siempre quieres procesar todos los elementos. En estos casos, usar where directamente en el bucle es una solución elegante y eficiente.

Por ejemplo, para mostrar solo los números pares:

for i in 1...10 where i % 2 == 0 {
   print("Es par \(i)")
}

Este enfoque evita condicionales innecesarios dentro del bucle y hace el código mucho más legible. Personalmente, es una de las características que más uso cuando quiero filtrar datos de forma rápida.

Obtener el índice y el valor

Podemos personalizar nuestro for para que también nos indique el índice de la iteración, además del valor de la misma:

for (index, i) in numeros.enumerated()  {
    print("Val \(i) - Indice \(index)")
}

Esto es especialmente útil cuando trabajas con listas que representan posiciones, estados o configuraciones.

El resultado sería:

Val 5 - Indice 0
Val 10 - Indice 1
Val 15 - Indice 2
Val 20 - Indice 3
Val 25 - Indice 4
Val 30 - Indice 5
Val 100 - Indice 6

El bucle while en Swift

Para el bucle o ciclo while en Swift es prácticamente lo mismo que en cualquier lenguaje de programación; tenemos un par de variaciones, el while tradicional y el llamado do-while o aquí en Swift sería el repeat-while:

while

La estructura básica del while es que mientras no se ejecute una condición, entonces este seguirá ejecutándose, a diferencia del for en el cual podemos ver un número de interacciones bien especificadas, aquí no:

while val > 10 {
    print(val)
    val += 1
}

Y obtenemos por resultado:

0
1
2
3
4
5
6
7
8
9

Ahora, si establecemos la siguiente configuración:

var val = 10

while val > 10 {
    print(val)
    val += 1
}

El ciclo no se ejecuta, ya que lo primero que hace el while es verificar si la condición aplica, pero como vimos en el caso anterior, esto es falso desde un inicio ya que 10 no es menor a 10 y por lo tanto el ciclo acaba antes de iniciar, pero si necesitamos que se ejecute al meno una vez sin importar la condición inicial, podemos emplear la siguiente estructura.

Aquí la condición se evalúa antes de cada iteración. Si la condición es falsa desde el inicio, el bucle no se ejecuta ni una sola vez.

Cómo funciona el while y cuándo usarlo

En mi experiencia, el while es ideal para:

• Procesos que dependen de estados
• Lectura de datos hasta que ocurre algo
• Lógica basada en condiciones dinámicas

Eso sí, hay que tener cuidado con los bucles infinitos si la condición nunca cambia.

Ejemplos prácticos de while en Swift

Un ejemplo muy común es controlar niveles o estados:

var currentLevel = 0
let finalLevel = 5
while currentLevel <= finalLevel {
   print("Has pasado el nivel \(currentLevel)")
   currentLevel += 1
}

El bucle repeat-while en Swift

El repeat-while es similar al while, con una diferencia clave:
el bloque se ejecuta al menos una vez, sin importar la condición inicial.

var val = 10

repeat {
    print(val)
    val += 1
} while val > 10 

Y obtenemos como salida:

10

Cómo ves, es la misma sintaxis, solo que desplazamos la verificación del while al final y al inicio colocamos la palabra reservada repeat.

Si partimos del ejemplo inicial, en donde val tenía un valor de cero, veremos que es la misma salida, ya que cuando val alcanza el valor de 10, inmediatamente la siguiente línea de código que se ejecuta es la verificación del while:

var val = 10

repeat {
    print(val)
    val += 1
} while val > 10 

La salida será:

10

Esto es muy útil cuando necesitas ejecutar una acción inicial antes de comprobar la condición.

• Diferencias entre while y repeat-while
• Característica    while    repeat-while
• Evalúa condición    Al inicio    Al final
• Ejecución mínima    0 veces    1 vez
• Uso típico    Iteraciones controladas    Validaciones iniciales

Casos reales donde repeat-while es la mejor opción

He usado repeat-while en:

• Menús interactivos
• Validaciones de entrada
• Procesos que deben ejecutarse al menos una vez

En estos escenarios, usar un while tradicional obliga a duplicar lógica.

For vs while en Swift: ¿cuál usar en cada caso?

• Usa for-in cuando:
  • Conoces el número de iteraciones
  • Recorres colecciones o rangos
• Usa while cuando:
  • No sabes cuántas veces se ejecutará el bucle
  • Dependes de una condición dinámica
• Usa repeat-while cuando:
  • Necesitas al menos una ejecución garantizada

Elegir bien el bucle hace que tu código sea más claro y mantenible.

Errores comunes al trabajar con bucles en Swift

Algunos errores típicos que he visto (y cometido):

• Crear bucles infinitos por no actualizar la condición
• Usar forEach cuando necesitas break
• Confundir rangos cerrados (...) con semiabiertos (..<)
• Acceder a índices fuera del array

Detectarlos a tiempo evita muchos bugs.

Preguntas frecuentes sobre bucles en Swift

• ¿Qué tipos de bucles existen en Swift?
  • Principalmente for-in, while y repeat-while.
• ¿Cuál es la diferencia entre for y while en Swift?
  • for se usa cuando conoces el número de iteraciones; while cuando depende de una condición.
• ¿Qué es stride en Swift?
  • Es una función que permite recorrer rangos con incrementos personalizados.
• ¿Se pueden recorrer arrays al revés en Swift?
  • Sí, usando reversed() o stride.

Conclusión: dominar los bucles en Swift

Los ciclos o bucles en Swift son fundamentales para cualquier desarrollador. Entender bien for-in, while y repeat-while te permitirá escribir código más eficiente, legible y seguro.

Si dominas estos conceptos desde el principio, avanzar en Swift se vuelve mucho más sencillo.