Implémenter la vérification nulle dans Kotlin

1. Utiliser des instructions conditionnelles pour implémenter une vérification Null dans Kotlin
2. Utiliser des appels sécurisés pour implémenter une vérification Null dans Kotlin
3. Utiliser l’opérateur Elvis pour implémenter une vérification Null dans Kotlin

Plusieurs types primitifs n’acceptent pas les erreurs null et génèrent des erreurs. Les erreurs commises avec des références null peuvent entraîner une défaillance de l’application ou même entraîner des plantages du système ; par conséquent, il est essentiel de vérifier les références null avant d’exécuter un programme.

Kotlin nous permet de vérifier null de différentes manières. Cet article vous apprendra comment vérifier null dans Kotlin et éviter les erreurs NullPointerException.

Utiliser des instructions conditionnelles pour implémenter une vérification Null dans Kotlin

Le moyen le plus simple de vérifier null dans Kotlin consiste à utiliser des instructions conditionnelles. Ici, nous pouvons utiliser les opérateurs conditionnels == ou != et exécuter les instructions conditionnelles en conséquence.

On peut aussi utiliser === au lieu de == et !== au lieu de !=. Une égalité structurelle x == null est de toute façon traduite en égalité référentielle x === null ; par conséquent, cela ne fait pas beaucoup de différence que vous utilisiez == ou ===.

Voici un exemple pour montrer l’utilisation d’instructions conditionnelles pour la vérification null dans Kotlin.

fun main() {
    val x: String? = "Android"
    if (x != null && x.length > 0) {
        print("This is not null, its length is: ${x.length}")
    } else {
        print("This is a null string!")
    }
}

Production:

Cliquez ici pour vérifier la démo de l’exemple.

Maintenant, si nous changeons la valeur en null, cela donnera l’autre sortie.

fun main() {
    val x: String? = null
    if (x != null && x.length > 0) {
        print("This is not null, its length is: ${x.length}")
    } else {
        print("This is a null string!")
    }
}

Production:

Cliquez ici pour vérifier la démo de l’exemple.

Les instructions conditionnelles ne fonctionnent que si la variable est déclarée à l’aide du mot-clé val. Le mot clé val rend le mot immuable.

Si nous utilisons une variable var, il y a des chances que la valeur de la variable change après avoir vérifié les références null.

Utiliser des appels sécurisés pour implémenter une vérification Null dans Kotlin

Les appels sécurisés sont une autre option pour accéder aux propriétés nullables pour la vérification null dans Kotlin. On peut utiliser l’opérateur d’appel sécurisé ?.. pour vérifier le résultat d’une expression.

Sur la base des résultats de l’expression, nous pouvons ensuite exécuter les autres instructions.

Voici un exemple.

fun main() {
    val v = "Android"
    val x: String? = null
    println(v?.length)
    println(x?.length)
}

Production:

Cliquez ici pour vérifier la démo de l’exemple.

Les appels sécurisés sont particulièrement utiles pour créer des chaînes. Par exemple, nous pouvons écrire :

a?.b?.c?.d

Dans l’exemple ci-dessus, si a n’est pas null, il passera à b. Si b n’est pas null, il se déplacera vers c, et si c n’est pas null, il se déplacera vers d.

Chaque fois que le compilateur trouve une valeur null, il arrête l’exécution et renvoie null.

Utiliser les appels sécurisés avec la fonction let pour gérer le Null dans Kotlin

Habituellement, si l’une des valeurs d’une liste est null, le compilateur renvoie null. Cependant, nous pouvons combiner la fonction let avec des appels sûrs pour ne travailler que sur des valeurs non null d’une liste.

Exemple:

fun main() {
    val myList: List<String?> = listOf("David", "Virat", "Steve", null)
    for (i in myList) {
        i?.let { println(it) } // prints only non-null values
    }
}

Production:

Cliquez ici pour vérifier la démo de l’exemple.

Utiliser l’opérateur Elvis pour implémenter une vérification Null dans Kotlin

Une autre excellente option pour la vérification null de Kotlin consiste à utiliser l’opérateur Elvis ?:. Il renverra une valeur non null ou une valeur par défaut s’il trouve une valeur null dans les références.

Il y a deux expressions : à gauche et à droite de l’opérateur Elvis. Si la valeur de l’expression de gauche n’est pas null, l’opérateur renvoie la valeur, mais si l’expression de gauche est null, l’opérateur Elvis renvoie la valeur de l’expression du côté droit.

La clé ici est que l’opérateur Elvis n’exécutera l’expression de droite que si l’expression de gauche est null.

Exemple:

fun main(args: Array<String>) {
    val i: String? = null
    val j: String = i ?: "Welcome! This is Kotlin Programming."
    // This print statement uses the Elvis operator
    println(i ?: j)
}

Production:

Cliquez ici pour vérifier la démo de l’exemple.