Kotlin
Sécurité nulle

Types nullables et non nullables

Les types normaux, tels que String , ne sont pas nullables. Pour les rendre capables de contenir des valeurs nulles, vous devez explicitement le noter en mettant un ? derrière eux: String?

var string        : String = "Hello World!"
var nullableString: String? = null

string = nullableString    // Compiler error: Can't assign nullable to non-nullable type.
nullableString = string    // This will work however!

Opérateur d'appel sécurisé

Pour accéder aux fonctions et propriétés des types nullables, vous devez utiliser des opérateurs spéciaux.

Le premier, ?. , vous donne la propriété ou la fonction à laquelle vous essayez d'accéder ou vous donne la valeur NULL si l'objet est nul:

val string: String? = "Hello World!"
print(string.length)   // Compile error: Can't directly access property of nullable type.
print(string?.length)  // Will print the string's length, or "null" if the string is null.

Idiom: appel de plusieurs méthodes sur le même objet vérifié par un objet nul

Une façon élégante d'appeler plusieurs méthodes d'un objet contrôlé nul utilise de Kotlin apply comme ceci:

obj?.apply { 
    foo()
    bar()
}

Cela appellera foo et bar sur obj (qui est this dans le apply bloc) que si obj est non nul, sauter le bloc entier autrement.

Pour amener une variable nullable dans la portée en tant que référence non nullable sans en faire le récepteur implicite des appels de fonctions et de propriétés, vous pouvez utiliser let au lieu d' apply :

nullable?.let { notnull ->
    notnull.foo()
    notnull.bar()
}

notnull pourrait être nommé quoi que ce soit, ou même à l' écart et utilisé par le paramètre implicite lambda it .

Smart cast

Si le compilateur peut déduire qu'un objet ne peut pas être nul à un certain point, vous n'avez plus besoin d'utiliser les opérateurs spéciaux:

var string: String? = "Hello!"
print(string.length)  // Compile error
if(string != null) {
    // The compiler now knows that string can't be null
    print(string.length)  // It works now!
}

Remarque: Le compilateur ne vous autorisera pas à convertir intelligemment les variables pouvant être modifiées entre la vérification null et l'utilisation prévue.

Si une variable est accessible en dehors de la portée du bloc actuel (parce que ce sont des membres d'un objet non local, par exemple), vous devez créer une nouvelle référence locale que vous pouvez ensuite convertir et utiliser intelligemment.

Elimine les valeurs NULL d'une Iterable et d'un tableau

Parfois, nous devons changer le type de Collection<T?> Collections<T> . Dans ce cas, filterNotNull est notre solution.

val a: List<Int?> = listOf(1, 2, 3, null)
val b: List<Int> = a.filterNotNull()

Coalescence Nul / Opérateur Elvis

Parfois, il est souhaitable d'évaluer une expression nullable d'une manière sinon. L'opérateur elvis, ?: , Peut être utilisé dans Kotlin pour une telle situation.

Par exemple:

val value: String = data?.first() ?: "Nothing here."

L'expression ci-dessus renvoie "Nothing here" si data?.first() ou data elle-même donne une valeur null else le résultat de data?.first() .

Il est également possible de lancer des exceptions en utilisant la même syntaxe pour annuler l'exécution du code.

val value: String = data?.second() 
    ?: throw IllegalArgumentException("Value can't be null!")

Rappel: NullPointerExceptions peut être lancé avec l' opérateur d'assertion (par exemple, les data!!.second()!! )

Affirmation

!! les suffixes ignorent la nullité et retournent une version non nulle de ce type. KotlinNullPointerException sera levée si l'objet est un null .

val message: String? = null
println(message!!) //KotlinNullPointerException thrown, app crashes

Elvis Operator (? :)

Dans Kotlin, nous pouvons déclarer une variable pouvant contenir une null reference . Supposons que nous ayons une référence nullable a , nous pouvons dire "si a n'est pas nul, utilisez-le, sinon utilisez une valeur non nulle x "

var a: String? = "Nullable String Value"

Maintenant, a peut être nul. Ainsi, lorsque nous devons accéder à la valeur de a , nous devons effectuer une vérification de sécurité, qu’elle contienne ou non de la valeur. Nous pouvons effectuer cette vérification de sécurité par une instruction if...else classique.

val b: Int = if (a != null) a.length else -1

Mais voici opérateur avance Elvis (opérateur Elvis: ?: ). Ci if...else dessus if...else peut être exprimé avec l'opérateur d'Elvis comme ci-dessous:

val b = a?.length ?: -1

Si l'expression à gauche de ?: (Ici: a?.length ) n'est pas nulle, l'opérateur elvis le renvoie, sinon il renvoie l'expression à droite (ici: -1 ). L'expression côté droit est évaluée uniquement si le côté gauche est nul.