En este post voy a hablar sobre los ciclos o loops en el lenguaje de programación Kotlin.

Kotlin tiene los tres ciclos básicos o esenciales:

1. for
2. while
3. do while

Ciclo for

El ciclo for es más utilizado para recorrer arreglos o rangos. No se puede declarar una variable dentro del ciclo, de hecho su declaración es omitida y se parece más al foreach de Java.

// Ciclo del 0 al 9
// usando un rango
// https://parzibyte.me/blog/2019/07/05/rangos-kotlin/
val rangoDeNumeros = 0..9
for (numero in rangoDeNumeros) {
    println(numero)
}

// Recorrer un arreglo
// Más sobre arreglos: https://parzibyte.me/blog/2019/07/02/arreglos-kotlin/
val nombres = arrayOf("John Galt", "Dagny Taggart", "Hank Rearden")
for (nombre in nombres) {
    println(nombre)
}

Como lo ves, para un ciclo que sería algo así:

for(var i = 0; i < 10; i++)

Se usa un rango con  0..9

Ciclo while

El ciclo while permite repetir determinada cosa mientras una condición se cumpla.

// Ciclo con while y contadores
var contador = 5
while (contador > 0) {
    println("Cuenta regresiva: $contador")
    contador--
}

Con un ciclo while se puede iterar un arreglo igualmente (la longitud del arreglo se obtiene con size):

// Recorrer un arreglo:
var indice = 0
while (indice < nombres.size) {
    println("Un nombre: ${nombres[indice]}")
    indice++
}

Una cosa que no es posible con los rangos es iterar con flotantes, pues bien, con un ciclo while es totalmente posible:

// Ciclo con flotantes
var contadorFlotantes = 0.1
while (contadorFlotantes < 1.0) {
    println("Contando del 0.1 al 1.0: $contadorFlotantes")
    contadorFlotantes += 0.1
}

Do while en Kotlin

Recuerda que la diferencia entre do while y while es que do while se ejecuta al menos una vez, incluso si la condición es falsa:

do {
    println("Me ejecuto una vez")
} while (false)

Con do while se puede hacer lo mismo que con los otros ciclos, tomando en cuenta la diferencia que ya mencioné.

Veamos un ejemplo:

// También existe el do while
var otroContador = 0
do {
    println("Contador: $otroContador")
    otroContador++
} while (otroContador < 5)

Repasando

En resumen, si quieres ir paso a paso en un rango, usa for con rangos. Lo mismo si quieres recorrer un arreglo.

Si quieres un ciclo más común, usa while.

Los ciclos do while casi no son usados, pero eso no significa que sean malos

Vamos a poner todo lo aprendido en el siguiente código:

fun main(argumentos: Array<String>) {
    /**
     * Ciclos en Kotlin:
     * while
     * do while
     * for
     *
     * @author parzibyte
     * @link https://parzibyte.me/blog
     * */

    // Ciclo del 0 al 9
    // usando un rango
    // https://parzibyte.me/blog/2019/07/05/rangos-kotlin/
    val rangoDeNumeros = 0..9
    for (numero in rangoDeNumeros) {
        println(numero)
    }

    // Recorrer un arreglo
    // Más sobre arreglos: https://parzibyte.me/blog/2019/07/02/arreglos-kotlin/
    val nombres = arrayOf("John Galt", "Dagny Taggart", "Hank Rearden")
    for (nombre in nombres) {
        println(nombre)
    }

    // Ciclo con while y contadores
    var contador = 5
    while (contador > 0) {
        println("Cuenta regresiva: $contador")
        contador--
    }

    do {
        println("Me ejecuto una vez")
    } while (false)

    // También existe el do while
    var otroContador = 0
    do {
        println("Contador: $otroContador")
        otroContador++
    } while (otroContador < 5)

    // Recorrer un arreglo:
    var indice = 0
    while (indice < nombres.size) {
        println("Un nombre: ${nombres[indice]}")
        indice++
    }

    // Ciclo con flotantes
    var contadorFlotantes = 0.1
    while (contadorFlotantes < 1.0) {
        println("Contando del 0.1 al 1.0: $contadorFlotantes")
        contadorFlotantes += 0.1
    }

}

Prueba el código en el playground.