Curso Kotlin | #13. Bucle For
Tags: spanish, kotlin, beginners, programming
Published: 2022-12-15 12:30:16

Bienvenido/a a otro capítulo del Curso de Kotlin! Podés consultar el curso completo desde [este link](https://github.com/maxwellnewage/kotlin-course) que te dejo acá. Podés seguirme por [LinkedIn](https://www.linkedin.com/in/maximilianoburgos/) o [Twitter](https://twitter.com/maxwellnewage) si querés estar al tanto de las próximas publicaciones.

El bucle For es uno de los más utilizados por todos los lenguajes de programación. Nos permite recorrer arrays y listas, como también generar iteraciones con un límite contabilizado. Vamos a verlo en detalle.

## Estructura e Implementación
Vamos a dejar descansar al ejemplo de la lotería por un tiempo, y nos embarcaremos en uno más sencillo. Imaginemos que tenemos un array de nombres:

```kotlin
val names = arrayOf(
    "Juan",
    "Marcos",
    "Tomas",
    "Silvina",
    "María",
    "Francisco"
)
```

Podría escribir los valores uno al lado de otro, pero me parece mucho más legible de esta manera. En las clases anteriores aprendimos que el método contentToString nos permitía imprimir nuestro arreglo. Esto nos sirve como desarrolladores, pero no nos conviene usarlo en una aplicación que verá el cliente. Por lo cual, vamos a aplicar el for:

```kotlin
for(name in names){
    println("Nombre: $name")
}
```

La variable iterativa name representa el valor de cada posición en el array names. Esto es equivalente a decir algo como “for(item in lista)”. Por lo cual esto va a imprimir todos los nombres de la lista:

```
Nombre: Juan
Nombre: Marcos
Nombre: Tomas
Nombre: Silvina
Nombre: María
Nombre: Francisco
```

Con todo lo que aprendimos en las clases anteriores, hoy podríamos generar esta lista de un modo más dinámico. Vamos a inicializar el array de nombres, pero vacío:

```kotlin
val names = arrayOf<String>().toMutableList()
```

Tenemos que convertirlos en un mutable list para obtener métodos que nos permitan agregar elementos. Luego necesitamos llenarlo con distintos nombres que nuestro programa pueda leer desde la consola:

```kotlin
while (true){
    println("Escribe un nombre, o tipea show para mostrar todos")
 
    val inputName = readLine()
 
    if(inputName.isNullOrEmpty()) {
        println("Debes escribir un nombre válido!")
    } else if(inputName == "show"){
        for(name in names){
            println("Nombre: $name")
        }
        break
    } else {
        names.add(inputName)
    }
}
```

No nos asustemos con la cantidad de código, analicemos linea por linea que hace este algoritmo:

```kotlin
while (true){
    println("Escribe un nombre, o tipea show para mostrar todos")
```

Queremos que se agreguen nombres hasta que escribamos “show” en la consola, por lo cual usaremos un bucle infinito.

```kotlin
if(inputName.isNullOrEmpty()) {
```

Validamos si el usuario dejó el campo en blanco, para evitar agregar valores vacíos a nuestro array.

```kotlin
} else if(inputName == "show"){
    for(name in names){
        println("Nombre: $name")
    }
    break
}
```

Si escribimos “show”, usaremos el for del principio y luego de imprimir los nombres, terminaremos el bucle con break. Podríamos no usar un salto y agregar nombres indefinidamente, pero quizá sería recomendable tener alguna forma de salir finalmente de nuestro programa.

## Sentencia Continue
Imaginemos ahora que necesitamos destacar ciertos nombres en el momento de mostrarlos. Si un nombre no comienza con “M”, queremos desearle un buen día (hoy tengo un gran bloqueo creativo, disculpas):

```kotlin
for(name in names){
    println("Nombre: $name")
 
    if(name.startsWith("M")){
        continue
    }
 
    println("Que tengas un gran día $name!")
}
```

Arranca el programa y agregamos los nombres “Max” y “Tom”. Esto nos dará como salida:

```
Nombre: Max
Nombre: Tom
Que tengas un gran día Tom!
```

Esto ocurre porque la sentencia continue le dice al for algo como: quiero que saltes esta iteración, pero continúes con el resto de los elementos. Si utilizáramos break, nos sacaría de la iteración estemos donde estemos. Entonces nosotros le dijimos que si la variable name empieza con (método startsWith) la letra “M”, entonces salte todo lo que sigue debajo, por lo cual no va a ejecutar el método println. Te recomiendo practicar incluyendo varios nombres para ver un resultado más notorio en el uso del continue.

## Conclusiones
Hoy solo vimos una parte del potencial en el uso del bucle for. Cuando trabajemos con listas en el futuro, le daremos una utilidad mucho más interesante.