Kotlin From Scratch Nullability, Loops e Conditions

Kotlin è un linguaggio di programmazione moderno che viene compilato in bytecode Java. È gratuito e open source e promette di rendere la codifica per Android ancora più divertente.  

Nell'articolo precedente, hai imparato a conoscere variabili, tipi semplici, matrici, commenti e inferenza di tipo in Kotlin. In questo tutorial, continueremo a imparare la lingua guardando a valori nulla, loop e condizioni in Kotlin.

1. Nullability

Se sei un programmatore Android, devi aver incontrato il famigerato NullPointerException errori nella tua app. Questi accadono ogni volta che provi a chiamare un metodo o leggere una proprietà di un riferimento a un oggetto che è nullo. 

La buona notizia è che Kotlin può aiutarci a evitare questo tipo di errore perché è un linguaggio sicuro. Ciò significa che le variabili non possono avere il valore null a meno che tu dichiari esplicitamente il loro tipo come annullabile. In altre parole, per impostazione predefinita, i tipi non possono essere nulli. Vediamo come questa caratteristica di Kotlin può aiutarci a evitare errori nel nostro codice. 

nome val: String = null // non verrà compilato

Come puoi vedere sopra, se assegniamo nullo al nome variabile, il compilatore si lamenterà. Affinché il compilatore consenta l'assegnazione, dichiara il nome come annullabile aggiungendo ? dopo il tipo.

nome di val: String? = null // compilerà name = "Chike" // nuovo valore è "Chike"

Si noti che se ? viene inserito dopo qualsiasi nome di tipo, abbiamo esplicitamente istruito il compilatore che il valore del tipo può o memorizzare un riferimento oggetto o può essere nullo-è nullable. Qui, lo abbiamo fatto con il Stringa digita, ma funziona allo stesso modo Int?, Byte?, Lungo?, La mia classe?, e così via. 

L'operatore di chiamata sicura: ?.

Impariamo di più su come funziona la sicurezza null in Kotlin con un operatore chiamato operatore di chiamata sicura ?..

nome var: stringa? = null print (name.length) // non verrà compilato

Il codice sopra non verrà compilato perché Kotlin è un linguaggio nullo. La variabile nome è assegnato il valore nullo. Ora, invocando la proprietà lunghezza su quella variabile si innescherebbe a NullPointerException errore in Java. Ma il compilatore Kotlin non permetterà il richiamo di questa proprietà perché la variabile potrebbe essere nullo. Il compilatore non ci permetterà di fare qualcosa che potrebbe generare a NullPointerException!

val v: String? = null print (v? .length) // compilerà e stamperà "null"

Ora, aggiungendo l'operatore di chiamata sicura ?. alla variabile prima di invocare la proprietà, abbiamo esplicitamente indicato al compilatore di invocare la proprietà solo se il valore non è nullo. Se il valore è nullo, il compilatore userà la stringa "nullo" come valore per noi. Funziona anche per metodi e non solo proprietà. 

Quando si chiama un metodo di un valore nullo, anche il tipo restituito sarà annullabile. Quindi, ad esempio, il tipo di ritorno di v? .length espressione quando v sarà annullabile Int?. 

val v: String? = null val len: Int? = v? .length print (len) // compilerà e stamperà "null"

Per bypassare il controllo di nullability con il compilatore Kotlin, possiamo sostituire il ?. operatore con !!.. Questo non è raccomandato, tuttavia, a causa dell'elevata probabilità di ottenere NullPointerException errori se usati.  

val v: String? = null val len: Int? = v !!. length print (len) // attiva un errore NullPointerException

L'operatore Elvis: ?:

Questo operatore ?: è chiamato l'operatore Elvis (perché la sua forma assomiglia alla testa di Elvis). È usato per fornire un valore alternativo per la variabile, se lo è nullo.  

val nomeutente = null nome: String = nome utente?: "Nessun nome" print (nome) // verrà compilato e stampato "Nessun nome"

Qui, il compilatore ha assegnato la stringa "Senza nome" alla variabile nome, perché il nome utente del primo valore è nullo. Se il primo valore non lo era nullo, allora quel valore verrebbe assegnato alla variabile.

2. Cicli

Kotlin ha while, do-while e for loops. 

Il mentre Ciclo continuo

Una dichiarazione di ripetizione ci consente di specificare che il codice dovrebbe ripetere un'azione mentre alcune condizioni rimangono vere.

Quindi in Kotlin, usando il mentre il ciclo è lo stesso di altri linguaggi come Java.

while (condition) // execute code here while (fuel> 5) driveMeAroundLagos ()

Finché la condizione è vera, verrà eseguito il codice all'interno delle parentesi graffe o del corpo del ciclo. Se la condizione è falsa, il codice non verrà eseguito. Nel nostro esempio precedente, una volta che la variabile di carburante diventa inferiore a 5 litri, la condizione diventa falsa e quindi il ciclo termina. In altre parole, driveMeAroundLagos () l'esecuzione del metodo si ferma. 

Il fare mentre Ciclo continuo

Kotlin ha anche il fare mentre costruisci il ciclo. 

do // execute code here while (condition)

Questo è simile al mentre dichiarazione. Nel ciclo while, il programma verifica la condizione di loop all'inizio del ciclo prima di eseguire il corpo del loop. Se la condizione è falsa, il corpo non viene eseguito. Ma il fare mentre loop verifica la condizione dopo l'esecuzione del corpo del loop. Ciò significa che il corpo viene eseguito almeno una volta.

Il per Ciclo continuo

UN per loop è un'istruzione di ripetizione che ci permette di scorrere gli oggetti mentre una determinata condizione è vera.

for (value in range) // Esegui codice 

In Kotlin, il per il costrutto loop funziona con iterazione su intervalli, collezioni o altri iterabili (spiegherò di più su questi nel prossimo post). Per i loop, lavorare insieme a nel operatore, che viene utilizzato per accertare se un valore è presente in un determinato intervallo.

for (a in 1 ... 5) print ("$ a") // stampa 1 2 3 4 5

Nel codice sopra, stiamo iterando attraverso un intervallo chiuso da 1 a 5 e stampando ogni valore nell'intervallo. 

Iterazione su una matrice di indici

Possiamo usare il withIndex () funzione o il indici proprietà su un array per iterare su un array in cui abbiamo bisogno dell'indice per ciascun elemento.

Usando il withIndex () Funzione

Possiamo scorrere su un array per accedere all'indice di ciascun elemento chiamando il withIndex () funzione sulla matrice, perché il withIndex () la funzione restituisce un iterable di IndexedValue scrivi per ogni elemento. Questo ci consente di accedere sia all'indice sia al valore di ogni elemento.

val numbersArray = intArrayOf (1,2,3,4,5) per ((indice, valore) in numbersArray.withIndex ()) print ("$ valore indice indice è $ valore \ n")

Il codice qui sopra stamperà il risultato qui sotto:

0 valore indice è 1 1 valore indice è 2 2 valore indice è 3 3 valore indice è 4 4 valore indice è 5

Usando il indici Proprietà

Inoltre, possiamo usare il indici proprietà sull'array. Ciò restituirà solo l'intervallo di indici validi per l'array.

val numbers1 = intArrayOf (1,2,3,4,5) per (indice in numeri1.indices) print ("$ valore indice indice è $ numeri1 [indice] \ n")

Il codice precedente produrrà lo stesso risultato dell'esempio precedente. Potete vedere anche qui che possiamo usare l'indice per accedere a un elemento dell'array, in modo simile ad altri linguaggi di programmazione come Java.

3. Condizioni

Kotlin ha tre tipi di dichiarazioni condizionali: il Se, se altro, e quando dichiarazioni. 

Il Se dichiarazione

Un Se l'istruzione esegue un codice se una condizione è vera o la salta semplicemente se la condizione è falsa. Niente di speciale qui: Se le dichiarazioni funzionano in modo simile a come fanno nella maggior parte degli altri linguaggi di programmazione, incluso Java. 

val number = 20 if (number% 2 == 0) print ("$ number is divisible by 2") // 20 è divisibile per 2

Possiamo anche controllare se una variabile è di un tipo particolare usando il è parola chiave. 

if (number is Int) print ("$ number is ante") 

Il se altro dichiarazione

Il se altro esegue un'azione se la condizione è vera ed esegue un'azione diversa se la condizione è falsa.

val number = 13 if (number% 2 == 0) print ("$ numero è divisibile per 2") else print ("$ numero non è divisibile per 2") // 13 non è divisibile per 2

Una delle principali funzionalità che distingue il se altro la dichiarazione in Kotlin da altri linguaggi di programmazione come Java è la capacità di assegnare una variabile dal valore restituito del  se altro dichiarazione. Questo è possibile perché a se altro la dichiarazione può essere usata non solo come una dichiarazione, ma anche come espressione in Kotlin.

val number = 13 val result = if (number% 2 == 0) "$ number is divisible by 2" else "$ number non è divisibile per 2" print (risultato) // 13 non è divisibile per 2

Nel codice sopra, abbiamo assegnato il risultato variabile con a Stringa oggetto basato sulla condizione del se altro dichiarazione. Si tenga presente che ciò restituirà solo l'ultima istruzione in un particolare blocco di condizioni e anche che non è possibile utilizzare un Se senza un altro come espressione. 

val result = if (number% 2 == 0) "Divisible by 2" "Number is $ number" // solo questa stringa viene restituita se eseguita else "Non divisibile per 2" "Number is $ number"

Il quando Espressione

Kotlin ha introdotto il quando costruire in sostituzione del familiare interruttore dichiarazione che abbiamo in diversi linguaggi di programmazione come C ++, Java e così via. quando è più conciso e ha caratteristiche più potenti del interruttore affermazione con cui potresti avere familiarità. 

Il quando la dichiarazione esegue diverse azioni in base ai possibili valori di una costante di tipo Int, Stringa, Byte, Corto, o qualsiasi altro oggetto. 

divertente guessTheNumber (numero: Int) quando (numero) 1 -> println ("numero è 1") 2 -> println ("numero è 2") 3 -> println ("numero è 3") altro -> println ("numero non è né 1, 2 o 3")

Nel codice sopra, abbiamo passato la funzione guessTheNumber () un parametro numerico (discuteremo delle funzioni in Kotlin in un post successivo). Il quando espressione quindi controlla se uno qualsiasi dei rami corrisponde al valore di numero e poi esegue l'azione su quel ramo. Se nessuno dei rami era una partita, il altro il ramo è eseguito. 

Un'altra variante del quando espressione non richiede alcun argomento, come nell'esempio sotto.

divertente guessTheNumber (numero: Int) quando number == 1 -> println ("numero è 1") numero == 2 -> println ("numero è 2") numero == 3 -> println ("numero è 3 ") else -> println (" numero non è né 1, 2 o 3 ")

Se vogliamo eseguire più di un'azione su un ramo, dobbiamo avvolgere le azioni in parentesi graffe .

valore val = 2 quando (numero) 1 -> println ("numero è 1") 2 -> // blocco di codice eseguito println ("numero è 2") println ("è un numero pari") 3 -> println ("numero è 3")

Inoltre, possiamo combinare i valori di test in un singolo ramo.

val number = 2 when (number) 1, 2 -> println ("numero è 1 o 2") // numero è 1 o 2 3 -> println ("numero è 3")

Qui, il primo ramo viene eseguito perché stiamo testando per un valore di 1 o 2.

Conclusione

In questo tutorial, hai imparato a conoscere nulla, loop e condizioni nel linguaggio di programmazione Kotlin. Nel prossimo tutorial della serie Kotlin From Scratch, imparerai a conoscere le gamme e le raccolte API in Kotlin. A presto!

Per saperne di più sulla lingua di Kotlin, ti consiglio di visitare la documentazione di Kotlin. Oppure guarda alcuni dei nostri altri tutorial di Kotlin qui su Envato Tuts+!