Utiliser la possibilité de valeur nulle en Kotlin

1. Avant de commencer

Cet atelier de programmation vous explique la possibilité de valeur nulle et l'importance de la sécurité null. La possibilité de valeur nulle peut être utilisée dans de nombreux langages de programmation. Elle désigne la possibilité pour les variables d'avoir une valeur nulle. En Kotlin, la possibilité de valeur nulle est traitée délibérément pour assurer la sécurité null.

Conditions préalables

• Vous connaissez les bases de la programmation Kotlin, y compris les variables, et les fonctions println() et main().
• Vous maîtrisez les conditions Kotlin, y compris les expressions if/else et les instructions booléennes.
• Vous connaissez les classes du langage Kotlin, y compris de la façon d'accéder aux méthodes et aux propriétés à partir d'une variable.

Points abordés

• À quoi correspond la valeur null.
• La différence entre les types nullable et non nullable.
• Ce qu'est la sécurité null, son importance et comment assurer la sécurité null en langage Kotlin.
• Comment accéder aux méthodes et propriétés des variables nullables avec l'opérateur d'appel sécurisé ?. et l'opérateur d'assertion "non nul" !!.
• Comment effectuer des vérifications null avec des conditions if/else.
• Comment convertir une variable nullable en une valeur non nullable avec des expressions if/else.
• Comment fournir une valeur par défaut lorsqu'une variable nullable est null avec l'expression if/else ou l'opérateur Elvis ?:.

Ce dont vous avez besoin

• Un navigateur Web ayant accès à Kotlin Playground.

2. Utiliser des variables nullables

Qu'est-ce que la valeur null ?

Dans le module 1, vous avez appris qu'en déclarant une variable, vous devez lui attribuer immédiatement une valeur. Par exemple, lorsque vous déclarez une variable favoriteActor, vous pouvez lui attribuer immédiatement une valeur de chaîne "Sandra Oh".

val favoriteActor = "Sandra Oh"

Vous n'avez pas d'acteur préféré ? Vous pouvez attribuer une valeur "Nobody" ou "None" à la variable. Ce n'est pas idéal, car votre programme interprète la variable favoriteActor comme ayant une valeur "Nobody" ou "None", plutôt qu'aucune valeur. En langage Kotlin, vous pouvez utiliser null pour indiquer qu'aucune valeur n'est associée à la variable.

Pour utiliser null dans le code, procédez comme suit :

1. Dans Kotlin Playground, remplacez le contenu du corps de la fonction main() par une variable favoriteActor définie sur null :

fun main() {
    val favoriteActor = null
}

2. Imprimez la valeur de la variable favoriteActor avec la fonction println(), puis exécutez ce programme :

fun main() {
    val favoriteActor = null
    println(favoriteActor)
}

Vous devriez obtenir ce résultat :

null

Réattributions de variables avec null

Précédemment, vous avez appris qu'il est possible de réattribuer des variables définies avec le mot clé var à différentes valeurs du même type. Par exemple, vous pouvez réattribuer une variable name déclarée avec un autre nom, à condition que le nouveau nom soit du type String.

var favoriteActor: String = "Sandra Oh"
favoriteActor = "Meryl Streep"

Après avoir déclaré une variable, vous devez parfois lui attribuer une valeur null. Par exemple, après avoir déclaré votre acteur préféré, vous décidez de ne plus le révéler. Dans ce cas, il est judicieux d'attribuer une valeur null à la variable favoriteActor.

Comprendre les variables nullables et non nullables

Pour réattribuer la valeur null à la variable favoriteActor, procédez comme suit :

1. Remplacez le mot clé val par un mot clé var, puis spécifiez que la variable favoriteActor est de type String et attribuez-lui le nom de votre acteur préféré :

fun main() {
    var favoriteActor: String = "Sandra Oh"
    println(favoriteActor)
}

2. Supprimez la fonction println() :

fun main() {
    var favoriteActor: String = "Sandra Oh"
}

3. Réattribuez la valeur null à la variable favoriteActor, puis exécutez ce programme :

fun main() {
    var favoriteActor: String = "Sandra Oh"
    favoriteActor = null
}

Le message d'erreur suivant s'affiche :

En langage Kotlin, il existe une distinction entre les types nullable et non nullable :

• Les types nullables sont des variables pouvant contenir null.
• Les types "non null" sont des variables qui ne peuvent pas contenir null.

Un type ne peut avoir une valeur nulle que si vous le laissez délibérément contenir la valeur null. Comme le message d'erreur l'indique, le type de données String est un type qui ne peut contenir une valeur nulle. Vous ne pouvez donc pas réattribuer la valeur null à la variable.

Pour déclarer des variables nullables en Kotlin, vous devez ajouter un opérateur ? après le type. Par exemple, le type String? peut contenir soit une chaîne, soit null, tandis qu'un type String ne peut contenir qu'une chaîne. Pour déclarer une variable nullable, vous devez ajouter délibérément le type nullable. Sans ce type, le compilateur Kotlin déduit qu'il ne peut pas avoir une valeur nulle.

4. Remplacez le type de variable favoriteActor d'un type de données String par un type de données String? :

fun main() {
    var favoriteActor: String? = "Sandra Oh"
    favoriteActor = null
}

5. Imprimez la variable favoriteActor avant et après la réattribution de la valeur null, puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = "Sandra Oh"
    println(favoriteActor)

    favoriteActor = null
    println(favoriteActor)
}

Vous devriez obtenir ce résultat :

Sandra Oh
null

La variable favoriteActor contenait initialement une chaîne, puis est convertie en null.

Essayez

Maintenant que vous pouvez utiliser le type String? nullable, pouvez-vous initialiser une variable avec une valeur Int et lui réattribuer la valeur null ?

Écrire une valeur Int nullable

1. Supprimez tout le code de la fonction main() :

fun main() {

}

2. Créez une variable number d'un type Int nullable, puis attribuez-lui la valeur 10 :

fun main() {
    var number: Int? = 10
}

3. Imprimez la variable number, puis exécutez ce programme :

fun main() {
    var number: Int? = 10
    println(number)
}

La sortie est conforme à vos attentes :

10

4. Réattribuez la valeur null à la variable number pour vérifier qu'elle peut avoir une valeur nulle :

fun main() {
    var number: Int? = 10
    println(number)

    number = null
}

5. Ajoutez une autre instruction println(number) à la dernière ligne du programme, puis exécutez-le :

fun main() {
    var number: Int? = 10
    println(number)

    number = null
    println(number)
}

La sortie est conforme à vos attentes :

10
null

3. Gérer les variables nullables

Précédemment, vous avez appris à utiliser l'opérateur . pour accéder aux méthodes et aux propriétés des variables non nullables. Dans cette section, vous apprendrez à l'utiliser pour accéder aux méthodes et aux propriétés des variables nullables.

Pour accéder à une propriété de la variable favoriteActor non nullable, procédez comme suit :

1. Supprimez tout le code de la fonction main(), puis déclarez une variable favoriteActor de type String et attribuez-lui le nom de votre acteur préféré :

fun main() {
    var favoriteActor: String = "Sandra Oh"
}

2. Affichez le nombre de caractères dans la valeur de la variable favoriteActor avec la propriété length, puis exécutez ce programme :

fun main() {
    var favoriteActor: String = "Sandra Oh"
    println(favoriteActor.length)
}

La sortie est conforme à vos attentes :

9

La valeur de la variable favoriteActor comprend neuf caractères, espaces compris. Le nombre de caractères présents dans le nom de votre acteur préféré peut varier.

Accéder à la propriété d'une variable nullable

Imaginons que vous souhaitez transformer la variable favoriteActor en variable nullable, afin que les personnes qui n'ont pas d'acteur préféré puissent lui attribuer la valeur null.

Pour accéder à une propriété de la variable nullable favoriteActor, procédez comme suit :

• Définissez un type nullable pour le type de la variable favoriteActor, puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = "Sandra Oh"
    println(favoriteActor.length)
}

Le message d'erreur suivant s'affiche :

Il s'agit d'une erreur de compilation. Comme indiqué dans un précédent atelier de programmation, une erreur de compilation se produit lorsque Kotlin ne parvient pas à compiler le code en raison d'une erreur de syntaxe.

Kotlin applique délibérément des règles de syntaxe pour assurer la sécurité null. Cela garantit qu'aucun appel accidentel n'est effectué sur les variables pouvant avoir une valeur null. Cela ne signifie pas pour autant que les variables ne peuvent pas avoir une valeur null. Cela signifie que si un membre d'une variable est consulté, la variable ne peut pas avoir une valeur null.

C'est essentiel, car si vous tentez d'accéder au membre d'une variable ayant une valeur null (appelé référence null) pendant l'exécution d'une application, celle-ci plantera, car la variable null ne contient aucune propriété ni méthode. Ce type de plantage est connu sous le nom d'erreur d'exécution. Il se produit après la compilation et l'exécution du code.

En raison de la nature de la sécurité null dans le langage Kotlin, ces erreurs d'exécution sont évitées, car le compilateur Kotlin force une vérification null pour les types susceptibles d'avoir une valeur nulle. La vérification Null désigne un processus permettant de vérifier si une variable peut avoir une valeur null avant que celle-ci ne soit consultée et traitée comme un type non nullable. Si vous souhaitez utiliser une valeur nullable de la même façon que son type non nullable, vous devez effectuer une vérification null délibérément. Pour en savoir plus à ce sujet, consultez Utiliser les expressions conditionnelles if/else dans la suite de cet atelier.

Dans cet exemple, le code échoue au moment de la compilation. En effet, la référence directe à la propriété length pour la variable favoriteActor n'est pas autorisée, car la variable peut avoir une valeur null.

Ensuite, vous découvrirez différentes techniques et opérateurs permettant d'utiliser les types nullables.

Utilisez l'opérateur d'appel sécurisé ?..

Vous pouvez utiliser l'opérateur d'appel sécurisé ?. pour accéder aux méthodes ou aux propriétés des variables nullables.

Pour utiliser l'opérateur d'appel sécurisé ?. afin d'accéder à une méthode ou à une propriété, ajoutez un symbole ? après le nom de la variable, puis accédez à la méthode ou à la propriété avec la notation ".".

L'opérateur d'appel sécurisé ?. permet un accès plus sûr aux variables nullables, car le compilateur Kotlin arrête toute tentative d'accès aux références null et renvoie null pour le membre consulté.

Pour accéder en toute sécurité à une propriété de la variable nullable favoriteActor, procédez comme suit :

1. Dans l'instruction println(), remplacez l'opérateur . par l'opérateur d'appel sécurisé ?. :

fun main() {
    var favoriteActor: String? = "Sandra Oh"
    println(favoriteActor?.length)
}

2. Exécutez ce programme, puis vérifiez que la sortie est conforme à vos attentes :

9

Le nombre de caractères présents dans le nom de votre acteur préféré peut varier.

3. Réattribuez la valeur null à la variable favoriteActor, puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = null
    println(favoriteActor?.length)
}

La sortie suivante s'affiche :

null

Vous remarquerez que le programme ne plante pas lorsque vous tentez d'accéder à la propriété length d'une variable null. L'expression d'appel sécurisé renvoie simplement null.

Utiliser l'opérateur d'assertion "non nul" !!

Vous pouvez également utiliser l'opérateur d'assertion "non nul" !! pour accéder aux méthodes ou propriétés des variables nullables.

Après la variable nullable, vous devez ajouter l'opérateur d'assertion "non nul" !!, suivi de l'opérateur ., puis de la méthode ou de la propriété sans espace.

Comme son nom l'indique, si vous utilisez l'assertion "non null" !!, alors vous affirmez que la valeur de la variable n'est pas null, qu'elle le soit ou non.

Contrairement aux opérateurs d'appel de sécurité ?., l'utilisation d'un opérateur d'assertion "non nul" !! peut générer une erreur NullPointerException si la variable nullable est effectivement null. Par conséquent, cette opération ne doit être effectuée que lorsque la variable est toujours non nullable ou que la gestion des exceptions a été correctement mise en place. Lorsqu'elles ne sont pas gérées de façon appropriée, les exceptions entraînent des erreurs d'exécution. Vous en apprendrez davantage sur la gestion des exceptions dans les prochains modules.

Pour accéder à une propriété de la variable favoriteActor avec l'opérateur d'assertion "non nul" !!, procédez comme suit :

1. Réattribuez la variable favoriteActor au nom de votre acteur préféré, puis remplacez l'opérateur d'appel sécurisé ?. par l'opérateur d'assertion "non nul" !! dans l'instruction println() :

fun main() {
    var favoriteActor: String? = "Sandra Oh"
    println(favoriteActor!!.length)
}

2. Exécutez ce programme, puis vérifiez que la sortie est conforme à vos attentes :

9

Le nombre de caractères présents dans le nom de votre acteur préféré peut varier.

3. Réattribuez la valeur null à la variable favoriteActor, puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = null
    println(favoriteActor!!.length)
}

Une erreur NullPointerException s'affiche :

Cette erreur Kotlin indique que votre programme a planté pendant l'exécution. Par conséquent, nous vous déconseillons d'utiliser l'opérateur d'assertion !! "non nul", sauf si vous êtes certain que la variable n'a pas une valeur null.

Utiliser les expressions conditionnelles if/else

Vous pouvez utiliser la branche if dans les expressions conditionnelles if/else pour effectuer des vérifications null.

Pour effectuer des vérifications null, vous pouvez vérifier que la variable nullable n'est pas égale à null en utilisant l'opérateur de comparaison !=.

Instructions if/else

Vous pouvez utiliser une instruction if/else avec une vérification null comme suit :

La vérification null est utile lorsqu'elle est combinée à une instruction if/else :

• La vérification null de l'expression nullableVariable != null est utilisée comme condition if.
• Le corps 1 de la branche if suppose que la variable est non nullable. Par conséquent, dans le corps, vous pouvez accéder librement aux méthodes ou aux propriétés de la variable, comme s'il s'agissait d'une variable non nullable (sans l'opérateur d'appel sécurisé ?. ni l'opérateur d'assertion "non nul" !!).
• Le corps 2 dans la branche else suppose que la variable est null. Par conséquent, dans le corps, vous pouvez ajouter des instructions à exécuter lorsque la variable est null. La branche else est facultative. Vous pouvez utiliser uniquement la condition if pour exécuter une vérification null sans fournir d'action par défaut lorsque la vérification null échoue.

La vérification null est plus pratique à utiliser avec la condition if lorsque plusieurs lignes de code utilisant une variable nullable. En revanche, l'opérateur d'appel sécurisé ?. est plus pratique pour une référence unique de la variable nullable.

Pour écrire une instruction if/else avec une vérification null pour la variable favoriteActor, procédez comme suit :

1. Attribuez à nouveau le nom de votre acteur préféré à la variable favoriteActor, puis supprimez l'instruction println() :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

}

2. Ajoutez une branche if avec une condition favoriteActor != null :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    if (favoriteActor != null) {

    }
}

3. Dans le corps de la branche if, ajoutez une instruction println qui accepte une chaîne "The number of characters in your favorite actor's name is ${favoriteActor.length}", puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    if (favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    }
}

La sortie est conforme à vos attentes.

The number of characters in your favorite actor's name is 9.

Le nombre de caractères présents dans le nom de votre acteur préféré peut varier.

Vous pouvez accéder à la méthode de longueur du nom directement avec l'opérateur ., car vous accédez à la méthode length dans la branche if après la vérification null. Par conséquent, le compilateur Kotlin sait qu'il n'est pas possible que la variable favoriteActor soit null. Il autorise donc un accès direct à la propriété.

4. Facultatif : Ajoutez une branche else pour gérer une situation dans laquelle le nom de l'acteur est null :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    if (favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    } else {

    }
}

5. Dans le corps de la branche else, ajoutez une instruction println qui accepte une chaîne "You didn't input a name." :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    if (favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    } else {
      println("You didn't input a name.")
    }
}

6. Attribuez la valeur null à favoriteActor, puis exécutez ce programme :

fun main() {
    var favoriteActor: String? = null

    if(favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    } else {
      println("You didn't input a name.")
    }
}

La sortie est conforme à vos attentes :

You didn't input a name.

Expressions if/else

Vous pouvez également combiner la vérification null avec une expression if/else pour convertir une variable nullable en une variable non nullable.

Pour attribuer une expression if/else à un type non nullable :

• La vérification null "nullableVariable != null" est utilisée comme condition if.
• Le corps 1 de la branche if suppose que la variable est non nullable. Par conséquent, dans le corps, vous pouvez accéder aux méthodes ou aux propriétés de la variable, comme s'il s'agissait d'une variable non nullable (sans l'opérateur d'appel sécurisé ?. ni l'opérateur d'assertion "non nul" !!).
• Le corps 2 dans la branche else suppose que la variable est null. Par conséquent, dans le corps, vous pouvez ajouter des instructions à exécuter lorsque la variable est null.
• Dans la dernière ligne des corps 1 et 2, vous devez utiliser une expression ou une valeur générant un type non nullable, afin qu'elle soit attribuée à la variable non nullable lorsque la vérification null réussit ou échoue, respectivement.

Pour utiliser l'expression if/else afin de réécrire le programme de sorte qu'il n'utilise qu'une seule instruction println, procédez comme suit :

1. Attribuez la variable favoriteActor au nom de votre acteur préféré :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    if (favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    } else {
      println("You didn't input a name.")
    }
}

2. Créez une variable lengthOfName, puis attribuez-la à l'expression if/else :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    val lengthOfName = if(favoriteActor != null) {
      println("The number of characters in your favorite actor's name is ${favoriteActor.length}.")
    } else {
      println("You didn't input a name.")
    }
}

3. Supprimez les instructions println() des branches if et else :

fun main() {
    var favoriteActor: String? = "Sandra Oh"

    val lengthOfName = if(favoriteActor != null) {

    } else {

    }
}

4. Dans le corps de la branche if, ajoutez une expression favoriteActor.length :

fun main() {
    val favoriteActor: String? = "Sandra Oh"

    val lengthOfName = if(favoriteActor != null) {
      favoriteActor.length
    } else {

    }
}

Vous accédez directement à la propriété length de la variable favoriteActor avec l'opérateur ..

5. Dans le corps de la branche else, ajoutez une valeur 0 :

fun main() {
    val favoriteActor: String? = "Sandra Oh"

    val lengthOfName = if(favoriteActor != null) {
      favoriteActor.length
    } else {
      0
    }
}

La valeur 0 est utilisée par défaut lorsque le nom est null.

6. À la fin de la fonction main(), ajoutez une instruction println qui accepte une chaîne "The number of characters in your favorite actor's name is $lengthOfName.", puis exécutez ce programme :

fun main() {
    val favoriteActor: String? = "Sandra Oh"

    val lengthOfName = if(favoriteActor != null) {
      favoriteActor.length
    } else {
      0
    }

    println("The number of characters in your favorite actor's name is $lengthOfName.")
}

La sortie est conforme à vos attentes :

The number of characters in your favorite actor's name is 9.

Le nombre de caractères présents dans le nom que vous avez utilisé peut varier.

Utiliser l'opérateur Elvis ?:

L'opérateur Elvis ?: est un opérateur que vous pouvez utiliser avec l'opérateur d'appel sécurisé ?.. Avec l'opérateur Elvis ?:, vous pouvez ajouter une valeur par défaut lorsque l'opérateur d'appel sécurisé ?. renvoie null. Il s'apparente à une expression if/else, mais il est plus idiomatique.

Si la variable n'est pas null, l'expression avant l'opérateur Elvis ?: s'exécute. Si la variable est null, l'expression après l'opérateur Elvis ?: s'exécute.

Pour modifier votre ancien programme afin d'utiliser l'opérateur Elvis ?:, procédez comme suit :

1. Supprimez l'expression conditionnelle if/else, puis définissez la variable lengthOfName sur la variable nullable favoriteActor et utilisez l'opérateur d'appel sécurisé ?. pour appeler sa propriété length :

fun main() {
    val favoriteActor: String? = "Sandra Oh"

    val lengthOfName = favoriteActor?.length

    println("The number of characters in your favorite actor's name is $lengthOfName.")
}

2. Après la propriété length, ajoutez l'opérateur Elvis ?: suivi d'une valeur 0, puis exécutez ce programme :

fun main() {
    val favoriteActor: String? = "Sandra Oh"

    val lengthOfName = favoriteActor?.length ?: 0

    println("The number of characters in your favorite actor's name is $lengthOfName.")
}

Le résultat est identique au résultat précédent :

The number of characters in your favorite actor's name is 9.

4. Conclusion

Félicitations ! Vous avez découvert la possibilité de valeur nulle et comment utiliser plusieurs opérateurs pour la gérer.

Résumé

• Vous pouvez définir une variable sur null pour indiquer qu'elle ne contient aucune valeur.
• Les variables non nullables ne peuvent pas être attribuées à la variable null.
• Les variables nullables peuvent être attribuées à null.
• Pour accéder aux méthodes ou aux propriétés des variables nullables, vous devez utiliser les opérateurs d'appel sécurisé ?. ou les opérateurs d'assertion "non nul" !!.
• Vous pouvez utiliser des instructions if/else avec des vérifications null pour accéder aux variables nullables dans des contextes non nullables.
• Vous pouvez convertir une variable nullable en un type non nullable avec des expressions if/else.
• Vous pouvez fournir une valeur par défaut lorsqu'une variable nullable est null avec l'expression if/else ou l'opérateur Elvis ?:.

En savoir plus

• Sécurité null