entre - val y var kotlin

La diferencia entre !! y? en Kotlin

Question

Soy nuevo en Kotlin . Quiero saber la diferencia entre estos dos !! y ? en el código de abajo.

¡Estoy teniendo debajo de dos fragmentos primero usando !! para mCurrentDataset y otro tener ? para la misma 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
}

Gracias por adelantado.

Answer 1

Como se dijo en kotlinlang.org/docs/reference/null-safety.html , !! Es una opción para los amantes de la NPE :)

a!!.length

devolverá un valor no nulo de a.length o lanzará una NullPointerException si a es null :

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

a?.length

devuelve a.length si a no es null , y null contrario:

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

Para resumir:

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

Podría ser útil: ¿Qué es una NullPointerException?

Answer 2

La precedencia de los operadores ! , ?. , !! es ?. > !! > ! .

el !! el operador levantará la KotlinNullPointerException cuando opera con una referencia null , por ejemplo:

null!!;// raise NullPointerException

¿La llamada segura ?. el operador devolverá null cuando opera en una referencia null , por ejemplo:

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

el !! El operador en su segunda aproximación puede generar NullPointerException si el lado izquierdo es null , por ejemplo:

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

Puedes usar el operador de elvis ?: lugar del !! operador en su caso, por ejemplo:

!(mCurrentDataset?.load(..)?:false)

Answer 3

Operador de SafeCall (?):

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

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

Operador de aserción (!!):

 val b: String? = "dd" //any value or null 
 val l = b!!.length 
//this throws null pointer exception if b is null otherwise returns actual

Answer 4

esto es ''!!'' El operador Double Bang siempre devuelve un valor no nulo y esto es ''?'' el operador de llamada segura devuelve valor si el valor no es nulo, y de lo contrario es nulo

Esta es una conversión de tipo anulable insegura (T?) A un tipo no anulable (T). Lanzará NullPointerException si el valor es nulo.

Está documentado kotlinlang.org/docs/reference/null-safety.html junto con los medios de seguridad nula de Kotlin.

ref - hotkey

Answer 5

In Addition to what Alexander said and as shown in the docs too, 

el ?. El operador de llamada segura es muy útil en el encadenamiento, algo como esto

student?.department?.hod?.name

Si no hay alumno, devuelve nulo, de lo contrario busque su departamento. Si el departamento no existe devuelve nulo, de lo contrario busque hod (jefe de departamento) y así sucesivamente.

Si alguno de estudiantes, departamento o hod es nulo, el resultado será nulo.