Kotlin - Flux de contrôle

Dans le chapitre précédent, nous avons découvert les différents types de types de données disponibles dans le système Kotlin. Dans ce chapitre, nous discuterons des différents types de mécanismes de contrôle de flux disponibles dans le Kotlin.

Sinon

Kotlin est un langage fonctionnel donc comme chaque langage fonctionnel de Kotlin “if”est une expression, ce n'est pas un mot-clé. L'expression“if”renverra une valeur chaque fois que nécessaire. Comme tout autre langage de programmation,“if-else”block est utilisé comme opérateur de contrôle conditionnel initial. Dans l'exemple suivant, nous comparerons deux variables et fournirons la sortie requise en conséquence.

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
}

Le morceau de code ci-dessus produit le résultat suivant dans le navigateur. Notre exemple contient également une autre ligne de code, qui décrit comment utiliser“If” déclaration comme une expression.

Maximum of a or b is 5

Utilisation de quand

Si vous êtes familier avec d'autres langages de programmation, vous avez peut-être entendu parler du terme instruction switch, qui est essentiellement un opérateur conditionnel lorsque plusieurs conditions peuvent être appliquées à une variable particulière. “when”L'opérateur compare la valeur de la variable aux conditions de la branche. S'il satisfait la condition de branchement, il exécutera l'instruction à l'intérieur de cette portée. Dans l'exemple suivant, nous en apprendrons plus sur «quand» à 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")
      }
   }
}

Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.

x is neither 1 nor 2

Dans l'exemple ci-dessus, le compilateur Kotlin correspond à la valeur de xavec les branches données. S'il ne correspond à aucune des branches, il exécutera la partie else. Pratiquement, quand équivaut à multiple if block. Kotlin offre une autre flexibilité au développeur, où le développeur peut fournir plusieurs contrôles dans la même ligne en fournissant «,» à l'intérieur des contrôles. Modifions l'exemple ci-dessus comme suit.

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")
      }
   }
}

Exécutez la même chose dans le navigateur, ce qui donnera la sortie suivante dans le navigateur.

x is neither 1 nor 2

Pour la boucle

Loop est une telle invention qui offre la flexibilité nécessaire pour parcourir tout type de structure de données. Comme d'autres langages de programmation, Kotlin fournit également de nombreux types de méthodologie de bouclage, cependant, parmi eux“For”est la plus réussie. L'implémentation et l'utilisation de la boucle For sont conceptuellement similaires à Java for loop. L'exemple suivant montre comment nous pouvons utiliser la même chose dans des exemples réels.

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

Dans le morceau de code ci-dessus, nous avons déclaré une liste nommée «éléments» et en utilisant la boucle for, nous parcourons cette liste définie et imprimons sa valeur dans le navigateur. Voici la sortie.

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

Voici un autre exemple de code, où nous utilisons une fonction de bibliothèque pour rendre notre travail de développement plus facile que jamais.

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")
   }
}

Une fois que nous compilons et exécutons le morceau de code ci-dessus dans notre base de codage, il produira la sortie suivante dans le navigateur.

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

Boucle While et Boucle Do-While

While et Do-While fonctionnent exactement de la même manière que dans d'autres langages de programmation. La seule différence entre ces deux boucles est que, en cas de boucle Do-while, la condition sera testée à la fin de la boucle. L'exemple suivant montre l'utilisation duWhile loop.

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

Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.

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

Kotlin a également une autre boucle appelée boucle Do-While, où le corps de la boucle sera exécuté une fois, alors seulement la condition sera vérifiée. L'exemple suivant montre l'utilisation duDo-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)
}

Le morceau de code ci-dessus produit la sortie suivante dans le navigateur. Dans le code ci-dessus, le compilateur Kotlin exécutera le bloc DO, puis il effectuera la vérification des conditions pendant le bloc.

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

Utilisation du retour, pause, continuer

Si vous connaissez un langage de programmation, vous devez avoir une idée des différents mots-clés qui nous aident à mettre en œuvre un bon flux de contrôle dans l'application. Voici les différents mots clés qui peuvent être utilisés pour contrôler les boucles ou tout autre type de flux de contrôle.

Return- Return est un mot-clé qui renvoie une valeur à la fonction appelante à partir de la fonction appelée. Dans l'exemple suivant, nous implémenterons ce scénario en utilisant notre base de codage 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;
}

Dans le morceau de code ci-dessus, nous appelons une autre fonction et multiplions l'entrée par 2, et renvoyons la valeur résultante à la fonction appelée qui est notre fonction principale. Kotlin définit la fonction d'une manière différente que nous examinerons dans un chapitre suivant. Pour l'instant, il suffit de comprendre que le code ci-dessus générera la sortie suivante dans le navigateur.

The value of X is--20

Continue & Break- Continuer et interrompre sont la partie la plus vitale d'un problème logique. Le mot clé «break» met fin au flux du contrôleur si une condition a échoué et «continue» fait le contraire. Toute cette opération se fait avec une visibilité immédiate. Kotlin est plus intelligent que les autres langages de programmation, dans lesquels le développeur peut appliquer plus d'une étiquette comme visibilité. Le morceau de code suivant montre comment nous implémentons cette étiquette dans 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]
      }
   }
}

Le morceau de code ci-dessus produit la sortie suivante dans le navigateur.

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

Comme vous pouvez le voir, le contrôleur continue la boucle, jusqu'à ce que et à moins que la valeur de x vaut 5. Une fois que la valeur de x atteint 5, il commence à exécuter le bloc if et une fois que l'instruction break est atteinte, tout le flux de contrôle met fin à l'exécution du programme.