Condizionali in Kotlin - Parte 1

In questo codelab Kotlin creerai un altro gioco di dadi, Lucky Dice Roll, in cui dovrai cercare di ottenere un numero fortunato. Il programma imposterà un numero fortunato e tirerà i dadi. Quindi, controlla il tiro rispetto al numero fortunato e stampa un messaggio appropriato nell'output. Per fare ciò, imparerai a confrontare i valori e a prendere decisioni diverse nel tuo programma Kotlin.

Per aiutarti a concentrarti sui concetti di programmazione senza doverti preoccupare dell'interfaccia utente dell'app, utilizzerai lo strumento di programmazione Kotlin basato su browser e visualizzerai i risultati nella console.

Prerequisiti

• Come aprire, modificare ed eseguire il codice in https://try.kotlinlang.org/
• Possibilità di creare ed eseguire un programma Kotlin che utilizza variabili, funzioni con argomenti, classi con metodi e stampa un risultato nella console.

Obiettivi didattici

• Come utilizzare le istruzioni if e else
• Come confrontare i valori utilizzando operatori come maggiore di (>), minore di (<) e uguale a (==).
• Come utilizzare le istruzioni when per scegliere un'opzione in base a un determinato valore.
• Che cos'è il tipo di dati Boolean e come utilizzare i valori true e false per prendere decisioni.

Cosa creerai

• Lucky Dice Roll, un gioco di dadi basato su Kotlin che ti consente di specificare un numero fortunato. Un giocatore vince se tira il numero fortunato.

Cosa serve

• Un computer con una connessione a internet.

Il programma Lucky Dice Roller deve determinare se l'utente ha tirato un numero fortunato e riceve un messaggio di congratulazioni oppure un messaggio che lo invita a riprovare.

In qualità di sviluppatore di app, dovrai prendere decisioni sul comportamento dell'app e creare risultati diversi per i tuoi utenti.

Se stai creando un'app di shopping, potresti mostrare schermate diverse in base alle opzioni di consegna scelte da un utente. Per un quiz, mostreresti schermate diverse a seconda che la risposta del giocatore sia corretta. A seconda dell'app, potrebbero esserci molti risultati possibili, che dovrai tenere in considerazione nel tuo codice.

Nel programma Lucky Dice Roller, l'app deve gestire diversi casi, ad esempio:

• Se il risultato del lancio dei dadi è il numero fortunato, mostra un messaggio di congratulazioni.
• Altrimenti , se il risultato del lancio dei dadi non è il numero fortunato, mostra un messaggio per riprovare.

Per aggiungere questa logica al tuo codice, utilizza parole chiave Kotlin speciali come if, else e when.

Vediamo alcuni esempi.

Utilizza un'istruzione if per impostare una condizione che viene soddisfatta

1. Esamina il codice riportato di seguito. Riesci a indovinare quale sarà l'output?

fun main() {
   val num = 5
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. Copia e incolla il codice nell'editor del programma Kotlin ed esegui il programma per osservare l'output.

The variable is greater than 4

La procedura decisionale per questo programma è la seguente:

1. Crea una variabile num e impostala su 5.
2. Se è vero che num è maggiore (>) di 4, stampa "The variable is greater than 4".
3. In tutte le altre situazioni, non fare nulla.

Nell'esempio precedente, num è impostato su 5. L'istruzione if confronta se la variabile è maggiore di 4. Poiché è vero, il sistema esegue le istruzioni tra parentesi graffe e stampa il messaggio.

Riepilogo: il simbolo > è un operatore per confrontare due valori, per verificare se il primo valore è maggiore del secondo e per restituire un risultato di true o false. Altri operatori comuni sono: < per minore di, == per uguale a, >= per maggiore o uguale a e <= per minore o uguale a.

Nota il formato generale dell'istruzione if:

• Inizia con la parola chiave if.
• Segui con due parentesi (). All'interno delle parentesi va la condizione. La condizione è qualsiasi cosa che possa essere true o false. Ad esempio, se un numero è maggiore di un altro.
• Segui con due parentesi graffe {}. All'interno delle parentesi graffe inserisci il codice da eseguire se la condizione è true.

if (condition-is-true) {
    execute-this-code
}

Tipo di dati booleano per i valori vero e falso:

• Un programma che verifica se una condizione è soddisfatta viene chiamato "valutazione della condizione". Il risultato della valutazione di una condizione è true se è soddisfatta o false se non è soddisfatta. Gli sviluppatori dicono anche "la condizione restituisce true" o "la condizione restituisce false".
• Le condizioni possono essere valutate solo come true o false.
• Proprio come esistono un tipo di dati Int per i numeri interi e IntRange per gli intervalli, esiste un tipo di dati per true e false, chiamato Boolean. Più avanti in questo corso incontrerai variabili di tipo Boolean.

Utilizza un'istruzione if per impostare una condizione che non viene soddisfatta

1. Modifica il valore di num in 3, come mostrato di seguito. Che cosa ti aspetti che succeda se esegui questo codice?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. Copia e incolla il codice nell'editor del programma Kotlin ed esegui il programma per osservare l'output.

Se num è impostato su 3, non viene stampato nulla perché il valore di num è inferiore a 4. Quindi, la condizione che num sia maggiore di 4 è false, il codice tra le parentesi graffe non viene eseguito e non viene stampato nulla.

Utilizza else per creare un'alternativa per le condizioni non soddisfatte

Anziché non fare nulla, puoi offrire ai tuoi utenti un'alternativa quando una condizione non viene soddisfatta. Come per il linguaggio normale, puoi farlo con un'istruzione else.

1. Aggiungi un'istruzione else per stampare un messaggio quando num non è maggiore di 4, come mostrato di seguito. Che cosa ti aspetti che succeda se esegui questo codice?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   } else {
       println("The variable is less than 4")
   }
}

2. Copia e incolla il codice nell'editor del programma Kotlin ed esegui il programma per osservare l'output.

The variable is less than 4

3. Tieni presente che quando num ha un valore di 3, il programma stampa il messaggio "The variable is less than 4" associato all'istruzione else perché num non è maggiore di 4 .
4. Modifica num in 5 ed esegui di nuovo il programma. Ora è vero che num è maggiore di 4 e il programma stampa "The variable is greater than 4".
5. Modifica num in 4 ed esegui il programma. Ora 4 non è maggiore di 4 e il programma stampa "The variable is less than 4".

Sebbene "The variable is less than 4" sia l'output corretto per le condizioni impostate nel codice, l'istruzione stampata non è precisa, poiché 4 non è minore di 4. Puoi aggiungere un'altra condizione che controlli la terza possibilità, ovvero se num è esattamente 4, e stampi un'istruzione corretta quando la condizione è vera.

Utilizza una combinazione di else + if per aggiungere condizioni alternative.

Puoi avere più di una condizione. Per il tuo esempio, ecco come puoi coprire tutte le possibilità per num:

• Se num è maggiore di 4, stampa "The variable is greater than 4".
• Altrimenti, se num è uguale a 4, stampa "The variable is equal to 4".
• Altrimenti, stampa "The variable is less than 4".

Questi vengono definiti casi diversi nell'istruzione if-else. Sono elencate tre richieste.

Il codice aggiornato ha il seguente aspetto:

fun main() {
   val num = 4
   if (num > 4) {
       println("The variable is greater than 4")
   } else if (num == 4) {
       println("The variable is equal to 4")
   } else {
       println("The variable is less than 4")
   }
}

Nota le seguenti modifiche:

• Il valore di num è ora impostato su 4, in modo da poter testare la nuova condizione.
• Tra le istruzioni if e else originali è presente una nuova istruzione else if per il caso in cui num sia esattamente 4.

1. Copia e incolla il codice riportato sopra nell'editor del programma Kotlin ed esegui il programma per osservare l'output.

The variable is equal to 4

2. Prova a modificare il valore di num e a vedere come influisce sull'output. Modifica num in 2 e 6, in modo da visualizzare ciascuna delle condizioni true.

Flusso di controllo

Se esamini le istruzioni if-else riportate sopra, il codice verrà eseguito o scorrerà in base alle condizioni. Il modo in cui guidi l'esecuzione con queste condizioni è chiamato "flusso di controllo" del programma.

• Supponiamo che il tuo tiro di dadi num sia 3. Il programma controlla la prima condizione (num > 4). Questa condizione è falsa, quindi il programma controlla la condizione successiva (num == 4), che è anch'essa falsa. Il programma esegue quindi il codice dell'istruzione else, che è l'opzione finale.
• Se il numero del tiro di dado è 6, la prima condizione (num > 4) è vera. Il programma stampa il messaggio "The variable is greater than 4". Poiché questa condizione è vera, non deve controllare il resto e l'istruzione if-else è completata.
• Utilizza una combinazione else + if per aggiungere condizioni alternative.

In questa sezione, utilizzando ciò che hai imparato nell'attività precedente, aggiornerai il programma Dice Roller per verificare se hai tirato un numero fortunato preimpostato. Se ce l'hai, hai vinto!

Configurare il codice di avvio

Stai avviando Lucky Dice Roller con un codice simile a quello della soluzione del programma Kotlin Dice Roller precedente. Puoi modificare la funzione main() nel codice precedente in modo che corrisponda oppure puoi copiare e incollare il codice riportato di seguito per iniziare.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

Controlla se è uscito il numero fortunato

Crea prima un numero fortunato, quindi confronta il risultato del lancio dei dadi con quel numero.

.

1. In main(), elimina l'istruzione println().
2. In main(), aggiungi un val chiamato luckyNumber e impostalo su 4. Il codice dovrebbe essere simile al seguente.

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
}

3. Di seguito, aggiungi un'istruzione if con una condizione tra parentesi () che controlla se rollResult è uguale (==) a luckyNumber. Lascia un po' di spazio tra le parentesi graffe {} per poter aggiungere altro codice.

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
    if (rollResult == luckyNumber) {

    }
}

4. All'interno delle parentesi graffe {}, aggiungi un'istruzione println per stampare "You win!"

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4

    if (rollResult == luckyNumber) {
        println("You win!")
    }
}

5. Esegui il programma. Potrebbe essere necessario eseguirlo più volte prima di avere fortuna e visualizzare il messaggio vincente nell'output.

You win!

Rispondere quando il numero fortunato non è stato estratto

Se l'utente non vince, non riceve alcun feedback dal programma, il che può portarlo a chiedersi se il programma non funzioni. È buona norma fornire sempre una risposta quando l'utente esegue un'azione. Per il programma Lucky Dice Roller, puoi comunicare ai partecipanti che non hanno vinto utilizzando l'istruzione else.

1. Aggiungi una dichiarazione else da stampare "You didn't win, try again!".

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else {
       println("You didn't win, try again!")
   }
}

2. Esegui il programma e, indipendentemente dal risultato, i tuoi utenti vengono sempre informati.

A questo punto, gli utenti sanno se hanno vinto o meno, ma non il motivo. Fornisci sempre agli utenti informazioni in modo che comprendano il risultato delle loro azioni. Immagina che il tuo programma sia una richiesta di prestito. "La tua richiesta non è stata approvata perché la tua affidabilità creditizia è scarsa" è molto più informativa di "Spiacenti, non possiamo concederti il prestito. Riprova." Per Lucky Dice Roller, puoi fornire agli utenti un messaggio informativo diverso per ogni tiro se hanno perso. Utilizza più istruzioni else if per farlo.

3. Aggiungi istruzioni else if per stampare un messaggio diverso per ogni rotolo. Se necessario, fai riferimento al formato che hai imparato nell'attività precedente.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else if (rollResult == 1) {
       println("So sorry! You rolled a 1. Try again!")
   } else if (rollResult == 2) {
       println("Sadly, you rolled a 2. Try again!")
   } else if (rollResult == 3) {
       println("Unfortunately, you rolled a 3. Try again!")
   } else if (rollResult == 4) {
       println("No luck! You rolled a 4. Try again!")
   } else if (rollResult == 5) {
       println("Don't cry! You rolled a 5. Try again!")
   } else {
       println("Apologies! you rolled a 6. Try again!")
   }
}

Nel codice riportato sopra,

• Controlla se rollResult è luckyNumber.
• Se rollResult è luckyNumber, stampa il messaggio vincente.
• In caso contrario, controlla se rollResult è 1 e, in caso affermativo, stampa un messaggio di riprova.
• In caso contrario, controlla se il valore di rollResult è 2 e, in tal caso, stampa un messaggio di riprova diverso.
• In caso contrario, continua a controllare fino al numero 5.
• Se il numero non è compreso tra 1 e 5, l'unica opzione rimasta è 6, quindi non è necessario un altro test con else if e puoi semplicemente acquisire l'ultima opzione con l'ultima istruzione else.

Suggerimento:puoi avere una sola istruzione if con una sola istruzione else in un blocco di codice if-else, ma nel mezzo puoi avere tutte le istruzioni else if di cui hai bisogno.

Poiché avere più casi else if è molto comune, Kotlin offre un modo più semplice per scriverli.

Il test di molti risultati o casi diversi è molto comune nella programmazione. A volte, l'elenco dei possibili risultati può essere molto lungo. Ad esempio, se lanci un dado a 12 facce, avrai 11 istruzioni else if tra la riuscita e il else finale. Per semplificare la scrittura e la lettura di questo tipo di istruzioni, il che aiuta a evitare errori, Kotlin rende disponibile un'istruzione when.

Stai per modificare il programma in modo che utilizzi un'istruzione when. Un'istruzione when inizia con la parola chiave when, seguita dalle parentesi (). All'interno delle parentesi va il valore da testare. Seguono le parentesi graffe {} per il codice da eseguire per condizioni diverse.

1. Nel tuo programma, in main(), seleziona il codice dalla prima istruzione if alla parentesi graffa } che chiude l'ultima istruzione else ed eliminalo.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4
}

2. In main(), sotto la dichiarazione di luckyNumber, crea un'istruzione when. Poiché when deve essere testato rispetto al risultato del lancio, inserisci rollResult tra le parentesi (). Aggiungi le parentesi graffe {} con un po' di spazio aggiuntivo, come mostrato di seguito.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {

   }
}

Come in precedenza, verifica innanzitutto se rollResult è uguale a luckyNumber.

1. All'interno delle parentesi graffe {} dell'istruzione when, aggiungi un'istruzione che verifica se rollResult è uguale a luckyNumber e, in caso affermativo, stampa il messaggio vincente. La dichiarazione ha il seguente aspetto:

luckyNumber -> println("You win!")

Ciò significa che:

• Per prima cosa inserisci il valore che stai confrontando con rollResult. Corrisponde a luckyNumber.
• Segui con una freccia (->).
• Poi aggiungi l'azione da eseguire in caso di corrispondenza.

Leggi questa frase come "Se rollResult è luckyNumber, stampa il messaggio "You win!"".

Il codice main() ha questo aspetto.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You win!")
   }
}

2. Utilizza lo stesso pattern per aggiungere righe e messaggi per i possibili tiri da 1 a 6, come mostrato di seguito. La funzione main() completata dovrebbe avere il seguente aspetto.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

3. Esegui il programma. L'output non cambia, ma il codice è molto più compatto e facile da leggere.

Complimenti! Hai imparato due modi per stampare i messaggi a seconda di una condizione. Si tratta di uno strumento potente per scrivere programmi interessanti.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

class Dice(val numSides: Int) {
   fun roll(): Int {
       return (1..numSides).random()
   }
}

• Utilizza un'istruzione if per impostare una condizione per l'esecuzione di alcune istruzioni. Ad esempio, se l'utente tira il numero fortunato, stampa un messaggio di vincita.
• Il tipo di dati Boolean ha valori true e false e può essere utilizzato per il processo decisionale.
• Confronta i valori utilizzando operatori come maggiore di (>), minore di (<) e uguale a (==).
• Utilizza una catena di istruzioni else if per impostare più condizioni. Ad esempio, stampa un messaggio diverso per ogni possibile tiro di dado.
• Utilizza un'istruzione else alla fine di una catena di condizioni per rilevare i casi che potrebbero non essere coperti in modo esplicito. Se copri i casi per i dadi a 6 facce, un'istruzione else rileverebbe i numeri 7 e 8 tirati con un dado a 8 facce.
• Utilizza un'istruzione when come forma compatta di esecuzione del codice in base al confronto di un valore.

Forma generale di if-else:

if (condition-is-true) {

execute-this-code

} else if (condition-is-true) {

execute-this-code

} else {

execute-this-code

}

When statement:

when (variable) {

matches-value -> execute-this-code

matches-value -> execute-this-code

...

}

• Kotlin: Control flow
• Kotlin: when
• Condizionali

Nota: le pratiche sono facoltative. Offrono l'opportunità di mettere in pratica ciò che hai imparato in questo codelab e a volte includono una sfida di programmazione.

Procedi nel seguente modo:

1. Modifica myFirstDice in modo che abbia 8 lati ed esegui il codice. Che cosa succede?

Suggerimento:quando aumenti il numero di lati, l'istruzione when non copre più tutti i casi, quindi per i casi non coperti non viene stampato nulla.

2. Correggi l'istruzione when in modo che tenga conto di tutti gli 8 lati. Puoi farlo aggiungendo casi per i numeri aggiuntivi. Sfida:anziché aggiungere un nuovo caso per ogni numero, utilizza un'istruzione else per rilevare tutti i casi non coperti esplicitamente.

Suggerimento:puoi aggiungere altre cover per coprire più lati. Questo è un buon modo per farlo, se vuoi un messaggio diverso per ogni numero che può essere estratto. In alternativa, puoi utilizzare un'istruzione else e stampare lo stesso messaggio per tutti i lati superiori a 6 coperti dal codice attuale.

3. Modifica myFirstDice in modo che abbia solo 4 lati. Che cosa succede?

Suggerimento : la modifica del numero di lati del dado a un valore inferiore a quello coperto dall'istruzione when non ha effetti evidenti, poiché tutti i casi che possono verificarsi sono coperti.