web-dev-qa-db-fra.com

La différence entre !! et ? à Kotlin

Je suis nouveau sur Kotlin . Je veux connaître la différence entre ces deux !! et ? dans le code ci-dessous.

J'ai au-dessous de deux bouts de code ayant d'abord utiliser !! pour mCurrentDataset et un autre ayant ? pour la même variable.

if(!mCurrentDataset!!.load(mDataSetString.get(mCurrentDataSelectionIndex), STORAGE_TYPE.STORAGE_APPRESOURCE))
{
    Log.d("MyActivity","Failed to load data.")
    return false
}

if(!mCurrentDataset?.load(mDataSetString.get(mCurrentDataSelectionIndex), STORAGE_TYPE.STORAGE_APPRESOURCE)!!)
{
    Log.d("MyActivity","Failed to load data.")
    return false
}

Merci d'avance.

kotlinkotlin-android-extensions
32
paril

Comme il est dit dans La référence Kotlin , !! est une option pour les amateurs de NPE :)

a!!.length

renverra une valeur non nulle de a.length ou émettra une NullPointerException si a est null:

val a: String? = null
print(a!!.length) // >>> NPE: trying to get length of null

a?.length

retourne a.length si a n'est pas null et null sinon:

val a: String? = null
print(a?.length) // >>> null is printed in the console

Pour résumer:

+------------+--------------------+---------------------+----------------------+
| a: String? |           a.length |           a?.length |           a!!.length |
+------------+--------------------+---------------------+----------------------+
|      "cat" | Compile time error |                   3 |                    3 |
|       null | Compile time error |                null | NullPointerException |
+------------+--------------------+---------------------+----------------------+

Pourrait être utile: Qu'est-ce qu'une exception NullPointerException?

54
Alexander Romanov

la priorité des opérateurs !, ?., !! est ?.> !!> !.

l'opérateur !! lève KotlinNullPointerException lorsqu'il opère sur une référence null, par exemple:

null!!;// raise NullPointerException

l'opérateur sûr appel ?. retournera null lorsqu'il opère sur une référence null, par exemple:

(null as? String)?.length; // return null;

l'opérateur !! dans votre deuxième approche peut lever NullPointerException si le côté gauche est null, par exemple:

mCurrentDataset?.load(..)!!
    ^-------------^
           | 
when mCurrentDataset== null || load() == null a NullPointerException raised.

vous pouvez utiliser l'opérateur elvis ?: au lieu de l'opérateur !! dans votre cas, par exemple:

!(mCurrentDataset?.load(..)?:false)
6
holi-java

c'est '!!' L'opérateur double-bang renvoie toujours une valeur non nulle et correspond à '?' l'opérateur d'appel sûr renvoie la valeur si la valeur n'est pas null et la valeur null sinon

Il s'agit d'une conversion de type nullable (T?) Non sécurisée en un type (N) non nullable. Il lancera NullPointerException si la valeur est null.

Il est documenté ici avec les moyens de sécurité nulle de Kotlin.

réf - raccourci clavier

4
kishu mewara

Opérateur SafeCall (?):

var a: String = "abc"
a = null  //compile time error

val b: String? = null
val result = b?.length//returns null

Opérateur d'assertion (!!):

 val b: String? = "dd" //any value or null 
 val l = b!!.length 
//this throws null pointer exception if b is null otherwise returns actual
0
Ramachandra Reddy Avula
In Addition to what Alexander said and as shown in the docs too,

l'opérateur d'opérateur ?. est très utile pour le chaînage, quelque chose comme ceci

student?.department?.hod?.name

s'il n'y a pas d'étudiant, renvoie null sinon cherche son département. Si le département n'existe pas, renvoie null, sinon recherchez hod (chef de département), etc.

Si l'un des étudiants, département ou hod est nul, le résultat sera nul.

0
Nitesh Ranjan