Kotlin - Kontrollfluss

Im vorherigen Kapitel haben wir verschiedene Arten von Datentypen kennengelernt, die im Kotlin-System verfügbar sind. In diesem Kapitel werden wir verschiedene Arten von Kontrollflussmechanismen diskutieren, die im Kotlin verfügbar sind.

Ansonsten

Kotlin ist eine funktionale Sprache, daher wie jede funktionale Sprache in Kotlin “if”ist ein Ausdruck, es ist kein Schlüsselwort. Der Ausdruck“if”gibt bei Bedarf einen Wert zurück. Wie andere Programmiersprachen,“if-else”Der Block wird als anfänglicher Bedingungsprüfungsoperator verwendet. Im folgenden Beispiel werden zwei Variablen verglichen und die erforderliche Ausgabe entsprechend bereitgestellt.

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
}

Der obige Code liefert die folgende Ausgabe als Ergebnis im Browser. Unser Beispiel enthält auch eine weitere Codezeile, in der die Verwendung beschrieben wird“If” Aussage als Ausdruck.

Maximum of a or b is 5

Verwendung von Wann

Wenn Sie mit anderen Programmiersprachen vertraut sind, haben Sie möglicherweise von dem Begriff switch-Anweisung gehört, der im Grunde ein bedingter Operator ist, wenn mehrere Bedingungen auf eine bestimmte Variable angewendet werden können. “when”Der Operator vergleicht den Variablenwert mit den Verzweigungsbedingungen. Wenn die Verzweigungsbedingung erfüllt ist, wird die Anweisung in diesem Bereich ausgeführt. Im folgenden Beispiel erfahren Sie mehr über das „Wann“ in 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")
      }
   }
}

Der obige Code liefert die folgende Ausgabe im Browser.

x is neither 1 nor 2

Im obigen Beispiel entspricht der Kotlin-Compiler dem Wert von xmit den angegebenen Zweigen. Wenn es keinem der Zweige entspricht, wird der else-Teil ausgeführt. In der Praxis entspricht when mehreren if-Blöcken. Kotlin bietet dem Entwickler eine weitere Flexibilität, bei der der Entwickler mehrere Überprüfungen in derselben Zeile bereitstellen kann, indem er "," in den Überprüfungen angibt. Lassen Sie uns das obige Beispiel wie folgt modifizieren.

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

Führen Sie dasselbe im Browser aus, wodurch die folgende Ausgabe im Browser angezeigt wird.

x is neither 1 nor 2

Für Schleife

Loop ist eine solche Erfindung, die die Flexibilität bietet, jede Art von Datenstruktur zu durchlaufen. Wie andere Programmiersprachen bietet Kotlin jedoch auch viele Arten von Looping-Methoden“For”ist der erfolgreichste. Die Implementierung und Verwendung der For-Schleife ähnelt konzeptionell der Java-for-Schleife. Das folgende Beispiel zeigt, wie wir dasselbe in realen Beispielen verwenden können.

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

Im obigen Code haben wir eine Liste mit dem Namen "items" deklariert. Mit der for-Schleife durchlaufen wir diese definierte Liste und drucken ihren Wert im Browser. Es folgt die Ausgabe.

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

Im Folgenden finden Sie ein weiteres Beispiel für Code, bei dem wir einige Bibliotheksfunktionen verwenden, um unsere Entwicklungsarbeit einfacher als je zuvor zu gestalten.

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

Sobald wir den obigen Code in unserem Codierungsgrund kompiliert und ausgeführt haben, wird die folgende Ausgabe im Browser ausgegeben.

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

While-Schleife und Do-While-Schleife

While und Do-While funktionieren genauso wie in anderen Programmiersprachen. Der einzige Unterschied zwischen diesen beiden Schleifen besteht darin, dass im Fall einer Do-while-Schleife die Bedingung am Ende der Schleife getestet wird. Das folgende Beispiel zeigt die Verwendung vonWhile loop.

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

Der obige Code liefert die folgende Ausgabe im Browser.

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

Kotlin hat auch eine andere Schleife namens Do-While-Schleife, in der der Schleifenkörper einmal ausgeführt wird, nur dann wird die Bedingung überprüft. Das folgende Beispiel zeigt die Verwendung vonDo-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)
}

Der obige Code liefert die folgende Ausgabe im Browser. Im obigen Code führt der Kotlin-Compiler den DO-Block aus und prüft dann die Bedingungen während des Blocks.

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

Verwendung von Return, Break, Continue

Wenn Sie mit einer Programmiersprache vertraut sind, müssen Sie eine Vorstellung von verschiedenen Schlüsselwörtern haben, die uns helfen, einen guten Kontrollfluss in der Anwendung zu implementieren. Im Folgenden sind die verschiedenen Schlüsselwörter aufgeführt, mit denen die Schleifen oder andere Arten von Steuerungsabläufen gesteuert werden können.

Return- Return ist ein Schlüsselwort, das von der aufgerufenen Funktion einen Wert an die aufrufende Funktion zurückgibt. Im folgenden Beispiel implementieren wir dieses Szenario mithilfe unserer Kotlin-Codierungsgrundlage.

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;
}

Im obigen Code rufen wir eine andere Funktion auf, multiplizieren die Eingabe mit 2 und geben den resultierenden Wert an die aufgerufene Funktion zurück, die unsere Hauptfunktion ist. Kotlin definiert die Funktion auf eine andere Art und Weise, die wir in einem nachfolgenden Kapitel betrachten werden. Im Moment reicht es zu verstehen, dass der obige Code die folgende Ausgabe im Browser generiert.

The value of X is--20

Continue & Break- Fortfahren und Unterbrechen sind der wichtigste Teil eines logischen Problems. Das Schlüsselwort "break" beendet den Controller-Fluss, wenn eine Bedingung fehlgeschlagen ist, und "continue" bewirkt das Gegenteil. All diese Vorgänge erfolgen mit sofortiger Sichtbarkeit. Kotlin ist intelligenter als andere Programmiersprachen, bei denen der Entwickler mehr als ein Etikett als Sichtbarkeit verwenden kann. Der folgende Code zeigt, wie wir dieses Label in Kotlin implementieren.

fun main(args: Array<String>) {
   println("Example of Break and Continue")
   myLabel@ 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")
         break@myLabel //specifing the label
      } else {
         println("I am inside else block with value"+x)
         continue@myLabel
      }
   }
}

Der obige Code liefert die folgende Ausgabe im Browser.

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

Wie Sie sehen können, setzt der Controller die Schleife fort, bis der Wert von x ist 5. Sobald der Wert von x erreicht 5, beginnt die Ausführung des if-Blocks und sobald die break-Anweisung erreicht ist, beendet der gesamte Kontrollfluss die Programmausführung.