Bucle multicondicional en Kotlin

Como todos sabemos acerca de los bucles, en Kotlin, los bucles se compilan en bucles optimizados siempre que sea posible. Por ejemplo, si itera sobre un rango de números, el código de bytes se compilará en un bucle correspondiente basado en valores int simples para evitar la sobrecarga de la creación de objetos. Los bucles condicionales son comunes a cualquier lenguaje de programación que elija. Si aplica varias condiciones a un bucle, se denomina bucle multicondicional. Aquí se ilustra un ejemplo simple de un bucle multicondicional en Java:

import java.io.*;
  
class GFG {
    public static void main (String[] args) {
      int [] data = {5, 6, 7, 1, 3, 4, 5, 7, 12, 13};
      for (int i=0; i<10 && i < data[i];i++) {
        System.out.println (data[i]);
      }
   }
}

El código anterior en ejecución imprimirá 5, 6 y 7. Veamos cómo podemos usar un bucle multicondicional en Kotlin. Veremos un enfoque funcional de lo mismo en Kotlin.

Ejemplo

El bucle multicondicional anterior se puede escribir en Kotlin así:

(0..9) .asSequence ( ) .takeWhile {
  it<numbers [it]
}.forEach
    println( "$it - ${data[it]}")
}

Es agradable, limpio y definitivamente no es una monstruosidad.

• Usamos takeWhile , que devuelve una secuencia que contiene los primeros elementos que satisfacen el predicado dado (en este caso, i <datos [i]).
• Aunque takewhile devuelve los primeros elementos que satisfacen el predicado dado, puede sentirse tentado a pensar que primero evaluará el rango completo y luego pasará a forEach .
• Ese habría sido el caso si no hubiéramos usado . como Secuencia(). Convertimos el rango en una Sequence<T> y, debido a esto, se evaluó de forma perezosa. En resumen, no procesará todo el conjunto de elementos con . takeWhile {…} y solo los verificará uno por uno cuando .forEach {. . . }está listo para procesar el siguiente elemento.

Primero, trabajaremos con una evaluación ansiosa sobre Iterable<T> . Esta es la versión entusiasta, que evalúa la primera función antes de pasar a la siguiente:

(0..9).takeWhile {
  println{"inside takewhile"}
  it<numbers[it]
}.forEach
    println( "inside forEach")
}

Producción:

Inside takeWhile
Inside takeWhile
Inside takeWhile
Inside takewhile
Inside forEach
Inside forEach
Inside forEach

Como puede ver, el rango se procesó primero con takewhile (que devolvió 0, 1, 2) y luego se envió para su procesamiento a forEach . Ahora, veamos la versión perezosa:

(0..9).asSequence().takewhile {
  printin ("Inside takewhile")
  it <numbers[it]
}.forEach{
  printin ("Inside forEach")
}

Producción:

Inside takewhile
Inside forEach
Inside takewhile
Inside forEach
Inside takewhile
Inside forEach
Inside takewhile

Como puede ver en el ejemplo anterior, takewhile se evalúa solo cuando forEach se usa para procesar un elemento. Esta es la naturaleza de Sequence<T> , que funciona con pereza siempre que sea posible.