Verwendung von Boolean? in if Ausdruck

Wenn ich eine Nullable habe Boolean b, kann ich den folgenden Vergleich in Java durchführen:

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

In Kotlin kann ich dasselbe erreichen, indem ich den !!Operator verwende:

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

Die Verwendung von !!fühlt sich für mich jedoch etwas skizzenhaft an und umgeht das Null-Sicherheitssystem.

Gibt es dafür einen eleganteren Ansatz?

Bearbeiten Es scheint, ich habe ein bisschen zu stark vereinfacht. Für lokale Variablen funktioniert es , wie Banthar zeigt. Mein Boolescher Wert bist jedoch tatsächlich eine "Eigenschaft mit einem Hintergrundfeld" (ich bin noch nicht wirklich auf dem neuesten Stand, was dies bedeutet). Das ist das Ergebnis:

Sie können auf NULL festlegbare boolean mit vergleichen true, falseoder nullunter Verwendung von Gleichheitsoperator:

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 
}

Wenn Sie sauber prüfen möchten, ob a Boolean?ist trueoder falseSie Folgendes tun können:

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

Wenn Sie überprüfen möchten, ob dies der Fall ist, können nullSie dies (oder else) als Wert in Folgendes einfügen when:

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

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

Kotlin analysiert Ihre Nullprüfungen statisch. Das ist in Ordnung:

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

Auch wenn dies mit einem Typfehler fehlschlägt:

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

Weitere Informationen finden Sie unter: http://kotlinlang.org/docs/reference/null-safety.html

Sie können auch den "Null-Koaleszenz-Operator" verwenden (der für veränderbare Variablen funktioniert):

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

Nach dem, was ich den Booleschen gesehen habe? ist das Ergebnis einer Methode, die Boolean für ein Objekt zurückgibt, das nullwertfähig ist

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

Die Lösung, die ich verwendet habe, besteht darin, die letFunktion zu verwenden, um den möglichen zurückgegebenen Nullwert wie folgt zu entfernen

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

In Kotlin können Sie Folgendes tun:

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

Fügen Sie zunächst die folgende benutzerdefinierte Inline-Funktion hinzu:

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
}

dann können Sie Code wie folgt schreiben:

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

//or

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

Für Kotlin benutze ich normalerweise

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

Dies würde nur funktionieren, wenn die Eigenschaft wahr ist und das Objekt nicht null ist. Für das Gegenteil:

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

Verwenden wir eine if-elseAnweisung mit 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!")
}

// Ergebnis: "Einer von ihnen ist nicht nullbar ..."

a = null
b = null

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

// Ergebnis: "Beide sind nullbar!"

Es ist ziemlich einfach, eine Erweiterungsfunktion hinzuzufügen, wenn dies hilfreich ist.

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

var x: Boolean? = null

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

Wenn Sie Operationen containan einem gleichermaßen ausführen möchten, können StringSie die Gleichheitsprüfung wie unten verwenden.

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

Sie können mit sicherem Operator "let" tun

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