Użycie wartości logicznej? w wyrażeniu if

Jeśli mam wartość null Boolean b, mogę wykonać następujące porównanie w Javie:

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

W Kotlinie to samo mogę osiągnąć za pomocą !!operatora:

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

Jednak użycie !!jest dla mnie trochę szkicowe, omijając zerowy system bezpieczeństwa.

Czy jest na to bardziej eleganckie podejście?

Edycja Wygląda na to, że trochę przesadziłem. W przypadku zmiennych lokalnych, jak pokazuje Banthar , działa. Jednak moja wartość logiczna bjest w rzeczywistości „właściwością z polem zapasowym” (nie jestem jeszcze na bieżąco z tym, co to narzuca). Oto wynik:

Można porównać zerowalne logiczną z true, falselub nullza pomocą operatora równości:

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 
}

Jeśli chcesz dokładnie sprawdzić, czy Boolean?jest truelub falsemożesz:

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

Jeśli chcesz sprawdzić, czy tak jest null, możesz dodać to (lub else) jako wartość w when:

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

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

Kotlin będzie analizować statycznie twoje czeki zerowe. Jest okej:

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

Mimo że to się nie powiedzie z błędem typu:

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

Więcej na: http://kotlinlang.org/docs/reference/null-safety.html

Możesz także użyć „operatora łączenia wartości null” (który będzie działał dla zmiennych zmiennych):

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

Z tego co widziałem Boolean? jest wynikiem metody, która zwraca wartość logiczną dla obiektu, który ma wartość null

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

Rozwiązaniem, którego używałem, jest użycie letfunkcji do usunięcia możliwej zwróconej wartości null w ten sposób

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

W Kotlinie możesz zrobić tak:

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

najpierw dodaj niestandardową funkcję wbudowaną poniżej:

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
}

możesz napisać taki kod:

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

//or

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

Dla Kotlina zwykle używam

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

działałoby to tylko wtedy, gdy właściwość ma wartość true, a obiekt nie jest pusty. Na odwrót:

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

Użyjmy if-elseinstrukcji z 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!")
}

// Wynik: „Jeden z nich nie dopuszcza wartości null ...”

a = null
b = null

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

// Wynik: „Oba są wartościami zerowymi!”

Dodanie funkcji rozszerzenia jest dość łatwe, jeśli ci to pomoże.

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

var x: Boolean? = null

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

W przypadku, gdy chcesz wykonać podobne operacje containna a, Stringmożesz użyć sprawdzenia równości, jak poniżej -

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

Możesz to zrobić z bezpiecznym operatorem „pozwól”

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