descargar - kotlin vs scala

El uso de booleano? en la expresión if

Question

Si tengo un Boolean b anulable, puedo hacer la siguiente comparación en Java:

Boolean b = ...;
if (b != null && b) {
   /* Do something */
} else {
   /* Do something else */
}

¡En Kotlin, puedo lograr lo mismo usando el !! operador:

val b: Boolean? = ...
if (b != null && b!!) {
   /* Do something */
} else {
   /* Do something else */
}

Sin embargo, el uso de !! me parece un poco vago, eludiendo el sistema de seguridad nulo.

¿Hay un enfoque más elegante para esto?

Editar Parece que exageré un poco. Para las variables locales, como muestra Banthar , funciona. Sin embargo, mi Boolean b es en realidad una "propiedad con un campo de respaldo" (todavía no estoy al tanto de lo que esto impone). Este es el resultado:

Answer 1

En Kotlin, puedes hacer así:

val b: Boolean? = true
if (b == true) { // if b is null, this should be null == true
    /* Do something */
} else {
    /* Do something else */
}

Answer 2

Es bastante fácil agregar una función de extensión si eso te ayuda.

fun Boolean?.orDefault(default: Boolean = false): Boolean {
    if (this == null)
        return default
    return this
}

var x: Boolean? = null

if(x.orDefault()) {
..
}

Answer 3

Kotlin analizará estáticamente sus cheques nulos. Esto esta bien:

val b: Boolean? = null
if (b != null && b) {
    println(b)
}

Aunque esto falla con el error de tipo:

val b: Boolean? = null
if (b == null && b) {
    println(b)
}

Para obtener más información, consulte: http://kotlinlang.org/docs/reference/null-safety.html

También puede usar el "operador de fusión nula" (que funcionará para variables mutables):

val b: Boolean? = null
if (b ?: false) {
    println(b)
}

Answer 4

Para Kotlin, lo que normalmente uso es if (object?.booleanProperty ==true) { //do stuff } esto solo funcionaría cuando la propiedad sea verdadera y el objeto no sea nulo. Para el reverso: if (!object?booleanProperty !=true) { //do Stuff}

Answer 5

Por lo que he visto el booleano? es el resultado de un método que devuelve un valor booleano en un objeto que puede contener nulos

val person: Person? = null
....
if(person?.isHome()) { //This won''t compile because the result is Boolean?
  //Do something
}

La solución que he estado usando es usar la función let para eliminar el posible valor nulo devuelto de esta manera

person?.let {
  if(it.isHome()) {
    //Do something
  }
}

Answer 6

Puede comparar un booleano anulable con true , false o null utilizando el operador de igualdad:

var b: Boolean? = null
if (b == true) {
    // b was not null and equal true
}

Answer 7

Si quieres comprobar limpiamente si un Boolean? es true o false puedes hacer:

when(b) {
    true -> {}
    false -> {}
}

Si desea verificar si es null , puede agregar eso (o else ) como un valor en el when :

when(b) {
    true -> {}
    false -> {}
    null -> {}
}

when(b) {
    true -> {}
    false -> {}
    else-> {}
}

Answer 8

Usemos una declaración if-else con un Elvis Operator :

val a: Boolean?
val b: Boolean?

a = true
b = null

if (a != null ?: b) { 
    println("One of them isn''t nullable...")
} else {
    println("Both are nullables!")
}

// Resultado: "Uno de ellos no es anulable ..."

a = null
b = null

if (a != null ?: b) { 
    println("One of them isn''t nullable...")
} else {
    println("Both are nullables!")
}

// Resultado: "¡Ambos son anulables!"