Kotlin From Scratch nullabilité, boucles et conditions

Kotlin est un langage de programmation moderne qui compile en bytecode Java. C'est gratuit et open source, et promet de rendre le codage pour Android encore plus amusant.  

Dans l'article précédent, vous avez appris sur les variables, les types simples, les tableaux, les commentaires et l'inférence de type dans Kotlin. Dans ce didacticiel, nous allons continuer à apprendre le langage en examinant la nullabilité, les boucles et les conditions dans Kotlin..

1. Nullabilité

Si vous êtes un codeur Android, vous devez être tombé sur l'infâme NullPointerException erreurs dans votre application. Cela se produit chaque fois que vous essayez d’appeler une méthode ou de lire une propriété d’une référence d’objet qui est nul. 

La bonne nouvelle est que Kotlin peut nous aider à éviter ce type d’erreur, car c’est un langage totalement sûr. Cela signifie que les variables ne peuvent pas avoir la valeur null sauf si vous déclarez explicitement que leur type est nullable. En d'autres termes, par défaut, les types ne peuvent pas être nuls. Voyons comment cette fonctionnalité de Kotlin peut nous aider à éviter les erreurs dans notre code. 

nom de la valeur: String = null // ne sera pas compilé

Comme vous pouvez le voir ci-dessus, si nous assignons nul au prénom variable, le compilateur va se plaindre. Pour que le compilateur autorise l’affectation, déclarez le nom nullable en ajoutant ? après le type.

nom de la valeur: String? = null // compilera name = "Chike" // la nouvelle valeur est "Chike"

Notez que si ? est inséré après tout nom de type, nous avons explicitement indiqué au compilateur que la valeur du type peut stocker une référence d'objet ou peut être nul-il est nul. Ici, nous l’avons fait avec le Chaîne tapez, mais cela fonctionne de la même façon avec Int?, Octet?, Longue?, Ma classe?, etc. 

Le responsable de l'appel sécurisé: ?.

Apprenons-en plus sur le fonctionnement de la sécurité nulle à Kotlin avec un opérateur appelé opérateur d'appels sûrs. ?..

Nom var: String? = null print (name.length) // ne sera pas compilé

Le code ci-dessus ne sera pas compilé car Kotlin est un langage null-safe. La variable prénom est assigné la valeur nul. Maintenant, invoquant la propriété longueur sur cette variable déclencherait une NullPointerException erreur en Java. Mais le compilateur Kotlin ne permet pas l’invocation de cette propriété car la variable pourrait être nul. Le compilateur ne nous permettra pas de faire quelque chose qui pourrait générer une NullPointerException!

val v: String? = null print (v? .length) // compilera et imprimera "null"

Maintenant, en ajoutant l'opérateur d'appel sécurisé ?. à la variable avant d'appeler la propriété, nous avons explicitement demandé au compilateur d'appeler la propriété uniquement si la valeur n'est pas nul. Si la valeur est nul, le compilateur utilisera la chaîne "nul" comme la valeur pour nous. Cela fonctionne aussi pour les méthodes et pas seulement les propriétés. 

Lorsque vous appelez une méthode de type nullable, le type de retour sera également nullable. Ainsi, par exemple, le type de retour du v? .longueur expression quand v est nullable sera Int?. 

val v: String? = null val len: Int? = v? .length print (len) // compilera et imprimera "null"

Pour contourner la vérification de la nullité par le compilateur Kotlin, nous pouvons remplacer le ?. opérateur avec !!.. Ceci n'est pas recommandé, cependant, en raison de la forte probabilité d'obtenir NullPointerException erreurs si utilisé.  

val v: String? = null val len: Int? = v !!. length print (len) // déclenche une erreur NullPointerException

L'opérateur Elvis: ?:

Cet opérateur ?: s'appelle l'opérateur Elvis (car sa forme ressemble à celle de la tête d'Elvis). Il est utilisé pour fournir une valeur alternative à la variable si elle est nul.  

val username = null val name: String = username?: "No name" print (name) // va compiler et afficher "No name"

Ici, le compilateur a attribué la chaîne "Sans nom" à la variable prénom, parce que le premier nom d'utilisateur de valeur est nul. Si la première valeur n'était pas nul, alors cette valeur serait assignée à la variable à la place.

2. boucles

Kotlin a des boucles while, do-while et for. 

le tandis que Boucle

Une instruction de répétition nous permet de spécifier que le code doit répéter une action tant qu'une condition reste vraie.

Donc, à Kotlin, en utilisant le tandis que la boucle est la même que dans d'autres langages tels que Java.

while (condition) // exécuter le code ici While (fuel> 5) driveMeAroundLagos ()

Tant que la condition est vraie, le code à l'intérieur des accolades ou du corps de la boucle sera exécuté. Si la condition est fausse, le code ne sera pas exécuté. Dans notre exemple ci-dessus, lorsque la variable de carburant devient inférieure à 5 litres, la condition devient fausse et la boucle se termine. En d'autres termes, driveMeAroundLagos () l'exécution de la méthode s'arrête. 

le faire pendant Boucle

Kotlin a aussi le faire pendant construction de boucle. 

faire // exécuter le code ici while (condition)

Ceci est similaire à la tandis que déclaration. Dans la boucle while, le programme teste la condition de la boucle au début de la boucle avant d'exécuter le corps de la boucle. Si la condition est fausse, le corps n'est pas exécuté. Mais le faire pendant loop teste la condition après l'exécution du corps de la boucle. Cela signifie que le corps est exécuté au moins une fois.

le pour Boucle

UNE pour boucle est une instruction de répétition qui nous permet d'itérer sur des objets lorsqu'une condition donnée est vraie.

for (valeur dans la plage) // code d'exécution 

À Kotlin, le pour la construction de boucle fonctionne avec l'itération sur des plages, des collections ou d'autres iterables (je vous en expliquerai plus dans le prochain post). Les boucles For fonctionnent avec le dans opérateur, qui sert à déterminer si une valeur est présente dans une plage donnée.

pour (a in 1… 5) print ("$ a") // imprimera 1 2 3 4 5

Dans le code ci-dessus, nous parcourons une plage fermée de 1 à 5 et imprimons chaque valeur dans la plage.. 

Itération sur un tableau d'index

Nous pouvons utiliser le avecIndex () fonction ou la des indices propriété sur un tableau à parcourir sur un tableau où nous avons besoin de l'index pour chaque élément.

En utilisant le avecIndex () Une fonction

Nous pouvons parcourir un tableau pour accéder à l'index de chaque élément en appelant le avecIndex () fonctionner sur le tableau, parce que le avecIndex () la fonction retourne un iterable de Valeur indexée tapez pour chaque élément. Cela nous permet d'accéder à la fois à l'index et à la valeur de chaque élément..

val numbersArray = intArrayOf (1,2,3,4,5) pour ((index, valeur) dans numbersArray.withIndex ()) print ("$ valeur d'index index est $ valeur \ n")

Le code ci-dessus imprimera le résultat ci-dessous:

0 valeur d'index est 1 1 valeur d'index est 2 2 valeur d'index est 3 3 valeur d'index est 4 4 valeur d'index est 5

En utilisant le des indices Propriété

De plus, nous pouvons utiliser le des indices propriété sur le tableau. Cela renverra uniquement la plage d'index valides du tableau..

val numbers1 = intArrayOf (1,2,3,4,5) pour (index in numbers1.indices) print ("La valeur de l'index $ index est $ numbers1 [index] \ n")

Le code ci-dessus produira le même résultat que l'exemple précédent. Vous pouvez également voir ici que nous pouvons utiliser l'index pour accéder à un élément de tableau, de la même manière que d'autres langages de programmation tels que Java..

3. Conditions

Kotlin a trois types d’énoncés de condition: le si, sinon, et quand des déclarations. 

le si Déclaration

Un si instruction exécute du code si une condition est vraie ou l'ignore simplement si la condition est fausse. Rien de spécial ici: si Les instructions fonctionnent de la même manière que dans la plupart des autres langages de programmation, y compris Java.. 

val number = 20 si (number% 2 == 0) print ("$ number est divisible par 2") // 20 est divisible par 2

Nous pouvons également vérifier si une variable est d'un type particulier en utilisant le est mot-clé. 

if (number is Int) print ("$ number est un entier") 

le sinon Déclaration

le sinon effectue une action si la condition est vraie et effectue une action différente si la condition est fausse.

nombre val = 13 si (nombre% 2 == 0) print ("le nombre $ est divisible par 2") else print ("le nombre $ n'est pas divisible par 2") // 13 n'est pas divisible par 2

Une caractéristique majeure qui distingue le sinon L’instruction en Kotlin à partir d’autres langages de programmation tels que Java permet d’affecter une variable à partir de la valeur renvoyée  sinon déclaration. Ceci est possible car un sinon déclaration peut être utilisée non seulement comme une déclaration, mais aussi comme une expression dans Kotlin.

val number = 13 val result = if (number% 2 == 0) "$ number est divisible par 2" else "$ number n'est pas divisible par 2" print (result) // 13 n'est pas divisible par 2

Dans le code ci-dessus, nous avons attribué le résultat variable avec un Chaîne objet basé sur l'état du sinon déclaration. Sachez que cela ne renvoie que la dernière instruction d’un bloc de conditions particulier et qu’il est également impossible d’utiliser un si sans un autre comme une expression. 

val result = if (number% 2 == 0) "Divisible par 2" "Le numéro est $ nombre" // seule cette chaîne est renvoyée si elle a été exécutée else "Non divisible par 2" "Le numéro est $ nombre"

le quand Expression

Kotlin a présenté le quand construire en remplacement du familier commutateur déclaration que nous avons dans différents langages de programmation tels que C ++, Java, etc.. quand est plus concis et possède des fonctionnalités plus puissantes que le commutateur déclaration que vous connaissez peut-être. 

le quand instruction effectue différentes actions en fonction des valeurs possibles d'une constante de type Int, Chaîne, Octet, Court, ou tout autre objet. 

fun guessTheNumber (number: Int) when (number) 1 -> println ("nombre est 1") 2 -> println ("nombre est 2") 3 -> println ("nombre est 3") sinon -> println ("le nombre n'est ni 1, 2 ni 3")

Dans le code ci-dessus, nous avons passé la fonction suppose que le numéro () un paramètre numérique (nous discuterons des fonctions dans Kotlin dans un post ultérieur). le quand expression vérifie ensuite si l’une des branches correspond à la valeur de nombre puis exécute l'action sur cette branche. Si aucune des branches était un match, le autre la branche est exécutée. 

Une autre variante du quand expression ne nécessite aucun argument, comme dans l'exemple ci-dessous.

amusementTheNumber (number: Int) when number == 1 -> println ("nombre est 1") nombre == 2 -> println ("nombre est 2") nombre == 3 -> println ("nombre est 3 ") else -> println (" le nombre n'est ni 1, 2 ni 3 ")

Si nous voulons exécuter plus d’une action sur une branche, nous devons envelopper les actions entre accolades. .

val nombre = 2 quand (nombre) 1 -> println ("nombre est 1") 2 -> // bloc de code exécuté println ("nombre est 2") println ("c'est un nombre pair") 3 -> println ("number is 3")

De plus, nous pouvons combiner des valeurs de test dans une seule branche.

val nombre = 2 quand (nombre) 1, 2 -> println ("nombre est soit 1 ou 2") // nombre est 1 ou 2 3 -> println ("nombre est 3")

Ici, la première branche est exécutée car nous testons une valeur de 1 ou 2.

Conclusion

Dans ce tutoriel, vous avez découvert la nullité, les boucles et les conditions dans le langage de programmation Kotlin. Dans le prochain didacticiel de la série Kotlin From Scratch, vous découvrirez les API de gammes et de collections de Kotlin. À bientôt!

Pour en savoir plus sur la langue Kotlin, je vous recommande de consulter la documentation Kotlin. Ou consultez certains de nos autres tutoriels sur Kotlin ici sur Envato Tuts+!