Kotlin: cicli for, while e do-while, break e continue

Ciclo for

Il ciclo for è utilizzato per ripere un’istruzione o un blocco di codice (racchiuso tra graffe) per un certo numero di volte. E’ possibile, grazie al ciclo for, iterare all’interno di array, range, collezioni o qualsiasi cosa che si possa iterare. La sintassi è quindi:

for(item in collection) {
//blocco da codice da eseguire
}

dove item è l’elemento della collezione (collection). La collezione può essere ad esempio un array o un range. Un modo per iterare da un certo valore iniziale ad uno finale con un determinato step di iterazione è:

for(item in 5 downTo 1 step 2)

in questo caso il valore iniziale è 5, il valore finale è 1 e lo step tra un’iterazione e la seguente è 2. Per maggiori informazioni visitate https://kotlinlang.org/docs/control-flow.html .

Array

Per iterare all’interno di un array è possibile ciclare sugli elementi (item), sull’indice (index) o su entrambi. Definendo così un array di numeri interi:

val arr = arrayOf(80, 20, 30, 10, 2)

• iterare sugli elementi: ovvero in ogni ciclo considerare l’elemento 80, 20, … . Esempio di utilizzo: for(item in arr) { }
• iterare sull’indice: ovvero in ogni ciclo considerare l’indice 0, 1, 2, … . Esempio di utilizzo: for(indexin arr.indices){ }
• iterare su elementi ed indice: ovvero in ogni ciclo ho sia l’indice che il valore dell’elemento ovvero (0,80), (1,20), (2,30), … . Esempio di utilizzo for((index, item) in arr.withIndex() {}

Ciclo while e do-while

Il ciclo while e do while, permettono di eseguire un’istruzione o un blocco di istruzioni (racchiuse tra parentesi graffe) fintanto che una determinata condizione non viene soddisfatta. La differenza tra i due cicli è solo il momento in cui viene controllata la condizione di uscita:

• while : la condizione viene controllata prima di eseguire l’istruzione o il blocco di istruzioni. Esempio di utilizzo while(condizione){}
• do while : la condizione viene controllata al termine dell’esecuzione dell’istruzione o del blocco di istruzioni. Questo vuol dire che tale istruzione o blocco di istruzioni verrà eseguito almeno una volta. Esempio di utilizzo do {} while(condizione); L’utilizzo di “;” dopo il while è necessario per distinguere il do while da un ciclo while.

Per maggiori informazioni visitate https://kotlinlang.org/docs/control-flow.html .

Break e continue

In Kotlin abbiamo tre modi per saltare da una linea di codice ad un’altra (structural jump expressions):

• return : il programma torna dal chiamante della funzione che si sta eseguendo.
• break : termina il ciclo che si sta eseguendo.
• continue : procede con il prossimo step del ciclo che si sta eseguendo.

Ogni espressione può essere, in Kotlin, segnata con un label. Queste hanno la forma di un nome dell’indicatore, seguito dal carattere “@” e si mettere all’inizio di una determinata espressione. I label si possono applicare in particolare alle espressioni break e continue. Infatti se dopo queste indichiamo il label “@” seguito dal nome dell’indicatore (labelId), allora il programma giunto durante la sua esecuzione:

• break@labelId : salta direttamente al ciclo identificato con labelId@
• continue@labelId : prosegue con il prossimo elemento del ciclo identificato come labelId@
• return@labelId value : torna all’espressione indientificata come labelId@ , ovvero permette di tornare da funzioni annidate o lambda.

Per maggiori informazioni visitate https://kotlinlang.org/docs/returns.html . Esempio di utilizzo:

fun main() {
    run() printid@ {
        exitid@ for ( i in 1..5 step 1) {
            loopid@ for ( j in 1..3 step 1) {
                print("[$i,$j] ")
                if(i == j) continue@exitid
                if(i < j) break@loopid
                if(j == 4) return@printid
            }
        }
    }
    return
}

che produce come output:

[1,1] [2,1] [2,2] [3,1] [3,2] [3,3] [4,1] [4,2] [4,3] [5,1] [5,2] [5,3]