Kotlin - Flusso di controllo

Nel capitolo precedente abbiamo imparato a conoscere i diversi tipi di tipi di dati disponibili nel sistema Kotlin. In questo capitolo, discuteremo i diversi tipi di meccanismi di controllo del flusso disponibili in Kotlin.

Se altro

Kotlin è un linguaggio funzionale quindi come ogni linguaggio funzionale in Kotlin “if”è un'espressione, non è una parola chiave. L'espressione“if”restituirà un valore ogni volta che sarà necessario. Come altri linguaggi di programmazione,“if-else”block viene utilizzato come operatore di controllo condizionale iniziale. Nell'esempio seguente, confronteremo due variabili e forniremo l'output richiesto di conseguenza.

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
}

La parte di codice precedente restituisce il seguente output come risultato nel browser. Il nostro esempio contiene anche un'altra riga di codice, che descrive come usare“If” dichiarazione come espressione.

Maximum of a or b is 5

Uso di quando

Se hai familiarità con altri linguaggi di programmazione, potresti aver sentito parlare del termine istruzione switch, che è fondamentalmente un operatore condizionale quando più condizioni possono essere applicate a una particolare variabile. “when”L'operatore confronta il valore della variabile con le condizioni del ramo. Se soddisfa la condizione del ramo, eseguirà l'istruzione all'interno di tale ambito. Nell'esempio seguente, impareremo di più sul "quando" 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")
      }
   }
}

La parte di codice precedente produce il seguente output nel browser.

x is neither 1 nor 2

Nell'esempio precedente, il compilatore Kotlin corrisponde al valore di xcon i rami dati. Se non corrisponde a nessuno dei rami, eseguirà la parte else. In pratica, quando è equivalente a multiplo if block. Kotlin fornisce un'altra flessibilità allo sviluppatore, in cui lo sviluppatore può fornire più controlli nella stessa riga fornendo "," all'interno dei controlli. Modifichiamo l'esempio sopra come segue.

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

Esegui lo stesso nel browser, che produrrà il seguente output nel browser.

x is neither 1 nor 2

Per Loop

Loop è una tale invenzione che fornisce la flessibilità di iterare attraverso qualsiasi tipo di struttura dati. Come altri linguaggi di programmazione, Kotlin fornisce anche molti tipi di metodologia di loop, tuttavia, tra di loro“For”è quello di maggior successo. L'implementazione e l'uso del ciclo For è concettualmente simile a Java per ciclo. Il seguente esempio mostra come possiamo usare lo stesso in esempi di vita reale.

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

Nella parte di codice sopra, abbiamo dichiarato un elenco denominato come "elementi" e utilizzando il ciclo for stiamo iterando l'elenco definito e stampando il suo valore nel browser. Di seguito è riportato l'output.

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

Di seguito è riportato un altro esempio di codice, in cui stiamo utilizzando alcune funzioni di libreria per rendere il nostro lavoro di sviluppo più semplice che mai.

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 volta compilato ed eseguito il pezzo di codice sopra nel nostro campo di codifica, produrrà il seguente output nel browser.

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 Loop e Do-While Loop

While e Do-While funzionano esattamente in modo simile a quello degli altri linguaggi di programmazione. L'unica differenza tra questi due loop è che, in caso di loop Do-while, la condizione verrà testata alla fine del loop. L'esempio seguente mostra l'utilizzo diWhile loop.

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

La parte di codice precedente produce il seguente output nel browser.

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

Kotlin ha anche un altro ciclo chiamato ciclo Do-While, in cui il corpo del ciclo verrà eseguito una volta, solo allora la condizione verrà verificata. L'esempio seguente mostra l'utilizzo diDo-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)
}

La parte di codice precedente produce il seguente output nel browser. Nel codice sopra, il compilatore Kotlin eseguirà il blocco DO, quindi eseguirà il controllo delle condizioni durante il blocco.

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 di Return, Break, Continue

Se hai familiarità con qualsiasi linguaggio di programmazione, devi avere un'idea delle diverse parole chiave che ci aiutano a implementare un buon flusso di controllo nell'applicazione. Di seguito sono riportate le diverse parole chiave che possono essere utilizzate per controllare i loop o qualsiasi altro tipo di flusso di controllo.

Return- Return è una parola chiave che restituisce un valore alla funzione chiamante dalla funzione chiamata. Nell'esempio seguente, implementeremo questo scenario utilizzando il nostro campo di codifica 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;
}

Nella parte di codice sopra, stiamo chiamando un'altra funzione e moltiplicando l'input per 2, e restituendo il valore risultante alla funzione chiamata che è la nostra funzione principale. Kotlin definisce la funzione in un modo diverso che vedremo in un capitolo successivo. Per ora, è sufficiente capire che il codice precedente genererà il seguente output nel browser.

The value of X is--20

Continue & Break- Continua e interrompi sono la parte più vitale di un problema logico. La parola chiave "break" termina il flusso del controller se una condizione non è riuscita e "continue" fa il contrario. Tutta questa operazione avviene con visibilità immediata. Kotlin è più intelligente di altri linguaggi di programmazione, in cui lo sviluppatore può applicare più di un'etichetta come visibilità. La parte di codice seguente mostra come implementiamo questa etichetta in 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]
      }
   }
}

La parte di codice precedente produce il seguente output nel 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

Come puoi vedere, il controller continua il ciclo, fino a quando ea meno che il valore di x è 5. Una volta che il valore di x raggiunge 5, inizia l'esecuzione del blocco if e una volta raggiunta l'istruzione break, l'intero flusso di controllo termina l'esecuzione del programma.