Utilisation de booléen? dans l'expression if

Si j'ai un nullable Boolean b, je peux faire la comparaison suivante en Java:

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

Dans Kotlin, je peux réaliser la même chose en utilisant l' !!opérateur:

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

Cependant, l'utilisation de !!me semble un peu sommaire, contournant le système de sécurité nul.

Y a-t-il une approche plus élégante pour cela?

Edit Il semble que j'ai un peu trop simplifié. Pour les variables locales, comme le montre Banthar , cela fonctionne. Cependant, mon booléen best en fait une "propriété avec un champ de sauvegarde" (je ne suis pas encore vraiment au courant de ce que cela impose). Voici le résultat:

Vous pouvez comparer avec booléenne annulable true, falseou en nullutilisant l' opérateur d'égalité:

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

Si vous voulez vérifier proprement si un Boolean?est trueou falsevous pouvez faire:

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

Si vous voulez vérifier si c'est, nullvous pouvez ajouter cela (ou else) en tant que valeur dans le when:

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

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

Kotlin analysera statiquement vos vérifications nulles. C'est bon:

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

Même si cela échoue avec une erreur de type:

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

Pour plus d'informations, voir: http://kotlinlang.org/docs/reference/null-safety.html

Vous pouvez également utiliser un "opérateur de fusion nul" (qui fonctionnera pour les variables mutables):

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

D'après ce que j'ai vu le booléen? est le résultat d'une méthode qui retourne Boolean sur un objet qui est nullable

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

La solution que j'ai utilisée consiste à utiliser la letfonction pour supprimer la possible valeur nulle renvoyée comme suit

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

Dans Kotlin, vous pouvez faire comme ceci:

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

tout d'abord, ajoutez la fonction en ligne personnalisée ci-dessous:

inline fun Boolean?.ifTrue(block: Boolean.() -> Unit): Boolean? {
    if (this == true) {
        block()
    }
    return this
}

inline fun Boolean?.ifFalse(block: Boolean?.() -> Unit): Boolean? {
    if (null == this || !this) {
        block()
    }

    return this
}

alors vous pouvez écrire un code comme celui-ci:

val b: Boolean? = ...
b.ifTrue {
   /* Do something in true case */
}

//or

b.ifFalse {
   /* Do something else in false case */
}

Pour Kotlin, ce que j'utilise normalement est

if (object?.booleanProperty ==true)
   { 
     //do stuff 
   }

cela ne fonctionnerait que lorsque la propriété est vraie et que l'objet n'est pas nul. Pour l'inverse:

if (!object?booleanProperty !=true)
   { 
     //do Stuff
   }

Utilisons une if-elseinstruction avec 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!")
}

// Résultat: "L'un d'eux n'est pas nullable ..."

a = null
b = null

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

// Résultat: "Les deux sont nullables!"

Il est assez facile d'ajouter une fonction d'extension si cela vous aide.

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

var x: Boolean? = null

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

Si vous souhaitez effectuer des opérations de la même manière containsur un, Stringvous pouvez utiliser le contrôle d'égalité comme ci-dessous

if (url?.contains("xxx") == true){
  return false;
}

Vous pouvez faire avec un opérateur sûr "let"

val b: Boolean? = null
b?.let { flag ->
    if(flag){
        // true Block
    } else {
        // false Block
    }
}