Kotlin - Flujo de control

En el capítulo anterior hemos aprendido acerca de los diferentes tipos de tipos de datos disponibles en el sistema Kotlin. En este capítulo, discutiremos diferentes tipos de mecanismos de control de flujo disponibles en Kotlin.

Si - Else

Kotlin es un lenguaje funcional, por lo tanto, como todos los lenguajes funcionales en Kotlin “if”es una expresión, no es una palabra clave. La expresion“if”devolverá un valor siempre que sea necesario. Como otros lenguajes de programación,“if-else”El bloque se utiliza como operador de verificación condicional inicial. En el siguiente ejemplo, compararemos dos variables y proporcionaremos el resultado requerido en consecuencia.

fun main(args: Array<String>) {
   val a:Int = 5
   val b:Int = 2
   var max: Int
   
   if (a > b) {
      max = a
   } else {
      max = b
   }
   print("Maximum of a or b is " +max)
 
   // As expression 
   // val max = if (a > b) a else b
}

El fragmento de código anterior produce el siguiente resultado como resultado en el navegador. Nuestro ejemplo también contiene otra línea de código, que describe cómo usar“If” declaración como expresión.

Maximum of a or b is 5

Uso de cuando

Si está familiarizado con otros lenguajes de programación, es posible que haya oído hablar del término declaración de cambio, que es básicamente un operador condicional cuando se pueden aplicar múltiples condiciones a una variable en particular. “when”El operador compara el valor de la variable con las condiciones de la rama. Si satisface la condición de la rama, ejecutará la declaración dentro de ese alcance. En el siguiente ejemplo, aprenderemos más sobre "cuándo" en Kotlin.

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1 -> print("x = = 1")
      2 -> print("x = = 2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

El fragmento de código anterior produce el siguiente resultado en el navegador.

x is neither 1 nor 2

En el ejemplo anterior, el compilador de Kotlin coincide con el valor de xcon las ramas dadas. Si no coincide con ninguna de las ramas, ejecutará la parte else. Prácticamente, when es equivalente a un bloque if múltiple. Kotlin proporciona otra flexibilidad al desarrollador, donde el desarrollador puede proporcionar varios cheques en la misma línea al proporcionar "," dentro de los cheques. Modifiquemos el ejemplo anterior como sigue.

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1,2 -> print(" Value of X either 1,2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

Ejecute lo mismo en el navegador, lo que producirá el siguiente resultado en el navegador.

x is neither 1 nor 2

En bucle

Loop es una invención de este tipo que proporciona la flexibilidad de iterar a través de cualquier tipo de estructura de datos. Al igual que otros lenguajes de programación, Kotlin también proporciona muchos tipos de metodología de bucle, sin embargo, entre ellos“For”es el más exitoso. La implementación y el uso de For loop es conceptualmente similar a Java for loop. El siguiente ejemplo muestra cómo podemos usar lo mismo en ejemplos de la vida real.

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   for (i in items) println("values of the array"+i)
}

En el fragmento de código anterior, hemos declarado una lista nombrada como "elementos" y usando el bucle for estamos iterando a través de esa lista definida e imprimiendo su valor en el navegador. A continuación se muestra la salida.

values of the array1
values of the array2
values of the array3
values of the array4

A continuación se muestra otro ejemplo de código, donde estamos usando alguna función de biblioteca para hacer que nuestro trabajo de desarrollo sea más fácil que nunca.

fun main(args: Array<String>) {
   val items = listOf(1, 22, 83, 4)
   
   for ((index, value) in items.withIndex()) {
      println("the element at $index is $value")
   }
}

Una vez que compilemos y ejecutemos el código anterior en nuestro campo de codificación, producirá el siguiente resultado en el navegador.

the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4

Bucle while y bucle Do-while

Mientras y Do-While funcionan exactamente de manera similar a como lo hacen en otros lenguajes de programación. La única diferencia entre estos dos bucles es que, en el caso del bucle Do-while, la condición se probará al final del bucle. El siguiente ejemplo muestra el uso de laWhile loop.

fun main(args: Array<String>) {
   var x:Int = 0
   println("Example of While Loop--")
   
   while(x< = 10) {
      println(x)
      x++
   } 
}

El fragmento de código anterior produce el siguiente resultado en el navegador.

Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10

Kotlin también tiene otro bucle llamado Do-While, donde el cuerpo del bucle se ejecutará una vez, solo entonces se verificará la condición. El siguiente ejemplo muestra el uso de laDo-while loop.

fun main(args: Array<String>) {
   var x:Int = 0
   do {
      x = x + 10
      println("I am inside Do block---"+x)
   } while(x <= 50)
}

El fragmento de código anterior produce el siguiente resultado en el navegador. En el código anterior, el compilador de Kotlin ejecutará el bloque DO, luego irá para verificar la condición en el bloque while.

I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60

Uso de devolución, descanso, continuación

Si está familiarizado con algún lenguaje de programación, entonces debe tener una idea de diferentes palabras clave que nos ayuden a implementar un buen flujo de control en la aplicación. A continuación se muestran las diferentes palabras clave que se pueden utilizar para controlar los bucles o cualquier otro tipo de flujo de control.

Return- Retorno es una palabra clave que devuelve algún valor a la función que llama desde la función llamada. En el siguiente ejemplo, implementaremos este escenario utilizando nuestro campo de codificación Kotlin.

fun main(args: Array<String>) {
   var x:Int = 10
   println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
   return 2*x;
}

En el fragmento de código anterior, llamamos a otra función y multiplicamos la entrada por 2, y devolvemos el valor resultante a la función llamada que es nuestra función principal. Kotlin define la función de una manera diferente que veremos en un capítulo posterior. Por ahora, es suficiente entender que el código anterior generará la siguiente salida en el navegador.

The value of X is--20

Continue & Break- Continuar y romper son la parte más vital de un problema lógico. La palabra clave "romper" termina el flujo del controlador si alguna condición ha fallado y "continuar" hace lo contrario. Toda esta operación ocurre con visibilidad inmediata. Kotlin es más inteligente que otros lenguajes de programación, donde el desarrollador puede aplicar más de una etiqueta como visibilidad. El siguiente fragmento de código muestra cómo estamos implementando esta etiqueta en Kotlin.

fun main(args: Array<String>) {
   println("Example of Break and Continue")
   [email protected] for(x in 1..10) { // appling the custom label
      if(x = = 5) {
         println("I am inside if block with value"+x+"\n-- hence it will close the operation")
         [email protected] //specifing the label
      } else {
         println("I am inside else block with value"+x)
         [email protected]
      }
   }
}

El fragmento de código anterior produce el siguiente resultado en el navegador.

Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operation

Como puede ver, el controlador continúa el bucle, hasta y a menos que el valor de x es 5. Una vez que el valor de x llega a 5, comienza a ejecutar el bloque if y una vez que se alcanza la instrucción break, todo el flujo de control termina la ejecución del programa.