Éliminer les risques de référence null dans Kotlin

En tant que développeur, l’un des bugs les plus récurant que l’on rencontre dans nos applications c’est NullPointerException. Cela se produit par exemple lorsqu’un utilisateur clique sur un bouton dans votre application et vous appelez une méthode sur une variable contenant une valeur null.

Imaginez un instant qu’aujourd’hui il est possible d’éliminer cette exception qui se produit durant l’exécution de vos applications.Cela est possible grâce au système de type de Kotlin qui vise à éliminer le risque de référence null dans votre code.

Dans ce tutoriel, nous allons voir comment éliminer les risques de référence null en Kotlin ( Kotlin Null Safety ) .

Types Null (Nullable types)

Par défaut dans kotlin, le compilateur n’autorise pas aux variables de référencer une valeur null. Par exemple ,le code suivant génère une erreur dans Kotlin

var nom: String = "Joel"
    nom = null; //Erreur: Null can not be a value of non-null type String

C’est grâce au système de nulabilité dans kotlin , que vous pouvez explicitement déclarer une variable pouvant contenir une valeur null ou non.

Ce qui permet donc au compilateur de savoir d’avance qu’une variable peut référencer une valeur null.Il pourra ainsi vous imposer de vérifier si cette variable est null avant d’appeler une méthode sur cette variable ou d’accéder à une propriété de cette variable.

C’est ainsi que Kotlin vous permet d’éliminer l’exception NullPointerException .Nous allons voir cela plus en détail.

Pour notifier au compilateur dans kotlin que vous souhaitez déclarer une variable pouvant contenir une valeur null, vous devez ajouter un point d’interrogation (?) après le type de la variable comme suit.

var nom: String? = "Joel"
    nom = null; 

En ajoutant un point d’ineterrogation à la fin du type de la variable nom dans l’exemple précédent, le compilateur sait que la variable nom peut contenir un valeur null et donc vous empêché d’appeler un méthode ou d’accéder à une propriété de la variable nom, pour éviter l’exception NullPointerException. .

Le code suivant ne fonctionne pas dans Kotlin

var nom: String? = "Joel"
    nom=null
    nom.length // Le compilateur génere une erreur
    nom.trim() // Le compilateur génere une erreur

Avant d’appeler une méthode ou d’accéder à une propriété d’une variable pouvant référencer une valeur null, vous devez vérifier que cette variable n’est pas null.

Types Non Null (Non-Null Types)

Par défaut une variable dans Kotlin est de type non null. Donc vous n’avez besoin de ne rien faire pour déclarer une variable de type non null

var nom: String = "Joel"
 val nb: Int = nom.length // Correct
 nom.trim() // Correct

A présent vous savez comment indiquer au compilateur que vous souhaitez avoir une variable pouvant contenir une valeur null. Et le compilateur vous empêchera d’appeler une méthode ou d’accéder à une propriété de cette variable pouvant contenir une valeur null.

Il vous reste à présent à savoir comment effectuer une vérification sur une variable pouvant contenir une valeur null avant de l’utiliser.Le compilateur vous aura ainsi épargner de l’exception NullPointerException .

Existe plusieurs manières de vérifier si une variable est null avant de pouvoir l’utiliser

Vérification de la nulabilité d’une variable

Pour vérifier si une variable est null avant de l’utiliser, vous devez effectuer une vérification comme on le fait dans la la plupart des langages tel que Java.Voir le code suivant

var nom: String? = "Joel"
    if( nom!=null){
      println("Bonjour Mr $nom")  
    }
    else{
      print("Vore nom est incorrect")
    }

L’opérateur d’appel sécurisé ?. ( Safe call operator: ? )

Il existe dans Kotlin, une manière simple et concise d’appeler une méthode sur une variable si et seulement si cette variable ne fait pas référence à une valeur null.

Cela est possible grâce à l’opérateur ?. .EN fait cette opérateur combine deux choses à la fois:

• Vérifier si la variable contient une valeur null
• Et l’appelle d’une méthode sur la variable si la valeur référencée par la variable n’est pas nul, tout cela se fait en une seul expression

Voir le code suivant

ar nom: String? = "Joel"
   nom?.toLowerCase()

L’opérateur d’appel sécurisé ?. et la méthode let

En utilisant l’opérateur ?. et la méthode let, vous pourrez exécuter un bloc de code lorsque la variable n’est pas null. Dans un prochain tutoriel nous parlerons de la méthode let dans Koltin.

var nom: String? = "Joel"
    nom?.let{
        it.toLowerCase()
        it.trim()
    }

L’opérateur Elvis: ?: (Elvis operator)

L’opérateur Elvis permet de définir une valeur par défaut lorsque le variable fait référence à un valeur null. Voir l’examole de code suivant

var nom: String? = "Joel" 
    val nomPersonne = nom ?: "Noe"

Vous pouvez combiner l’opérateur d’appel sécurisé (?.) et l’opérateur Elvis (?:) pour affecter une valeur par défaut lorsque la variable sur laquelle la méthode est appelé est null ou lorsque la variable sur laquelle on n’essai d’accéder à une propriété est null .

Donc l’opérateur Elvis permet de fournir une valeur par défaut ou d’exécuter une bloc de code lorsque la valeur contenu dans la variable vérifiée par l’opérateur d’appel sécurisé est null.

Voir l’exemple de code suivant

var nom: String? = "Joel"
    val rep: String = nom?.toLowerCase() ?: "Votre nom est incorrect"

La valeur contenue dans la variable rep est « Joel »

var nom: String? = null
    val rep: String = nom?.toLowerCase() ?: "Votre nom est incorrect"

La valeur contenue dans la variable rep est « Votre nom est incorrect »

L’opérateur !! (The !! Operator)

L’opérateur d’assertion non null !!, contrairement à l’opérateur d’appel sécurisé (?.) permet de convertir une variable de type null en une variable de type non null puis lance l’exception NullPointerException si:

• cette variable contient une valeur null
• et on essai d’appeler une méthode ou on essaie d’accéder à une propriété de cette variable

Voir l’exemple de code suivant.

var nom: String? = null
    nom!!.toLowerCase() //Erreur

Collections of Nullable Type

L’API Collection de Kotlin, vous permet de déclarer une collection pouvant contenir des éléments null

Voir l’exemple de code suivant

val listNumbers: List<Int?> = listOf(1,2,null,4)

Pour filtrer la collection et récupérer uniquement les éléments non null,on procède ainsi

val listNumbers: List<Int?> = listOf(1,2,null,4)
val listNumbers2: List<Int> =listNumbers.filterNotNull()    

 Nullable Collection

Dans Kotlin vous pouvez aussi déclarer un collection pouvant être null comme suit

var listNumbers: List<Int>? = listOf(1,2,4)
    listNumbers = null // On définit la valeur de la collection à null

Nullable Collection of Nullable Types

Vous pouvez aussi déclarer une collection pouvant être null et pouvant contenir des éléments null comme suit

var listNumbers: List<Int?>? = listOf(1,2,4,null,6,null)
    listNumbers = null // On définit la valeur de la collection à null

Conclusion

Dans ce tutoriel nous avons appris comment éliminer les risques de référence null en vérifiant de manière simple et concise les variables pouvant contenir une valeur null avant de les utilisées.