Boole kullanımı? if ifadesinde

Null değerim varsa Boolean b, Java'da aşağıdaki karşılaştırmayı yapabilirim:

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

Kotlin'de !!operatörü kullanarak aynısını başarabilirim :

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

Bununla birlikte, !!boş güvenlik sistemini atlatarak, kullanımı bana biraz kabataslak geliyor.

Bunun için daha zarif bir yaklaşım var mı?

Düzenle Görünüşe göre biraz fazla basitleştirdim. Banthar'ın gösterdiği gibi yerel değişkenler için işe yarıyor. Bununla birlikte, benim Boole'm baslında bir "destek alanı olan bir özelliktir" (bunun ne anlama geldiğini henüz tam olarak bilmiyorum). Sonuç şu:

Sen null ile boole'sini karşılaştırabilirsiniz true, falseya nulleşitlik operatörü kullanılarak:

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 
}

Eğer temiz bir şekilde kontrol etmek istiyorsanız ister Boolean?ise trueya falseYapabileceğiniz:

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

Kontrol etmek nullistiyorsanız, bunu (veya else) aşağıdakilere bir değer olarak ekleyebilirsiniz when:

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

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

Kotlin, boş çeklerinizi statik olarak analiz edecektir. Bu iyi:

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

Bu, tür hatasıyla başarısız olsa da:

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

Daha fazla bilgi için bkz: http://kotlinlang.org/docs/reference/null-safety.html

Ayrıca "boş birleştirme operatörü" de kullanabilirsiniz (değişebilir değişkenler için çalışacaktır):

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

Boolean'ı gördüğümden mi? boş değer atanabilir bir nesnede Boolean döndüren bir yöntemin sonucudur

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

Kullanmakta olduğum çözüm, letişlevi döndürülen olası boş değeri kaldırmak için kullanmaktır.

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

Kotlin'de şunu yapabilirsiniz:

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

ilk olarak, özel satır içi işlevi aşağıya ekleyin:

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
}

o zaman şu şekilde kod yazabilirsiniz:

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

//or

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

Kotlin için normalde kullandığım şey

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

bu yalnızca özellik true olduğunda ve nesne boş olmadığında çalışır. Tersi için:

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

Bir if-elseifade kullanalım 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!")
}

// Sonuç: "Bir tanesi boş değer atanamaz ..."

a = null
b = null

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

// Sonuç: "Her ikisi de boş değerdir!"

Size yardımcı olacaksa, bir uzantı işlevi eklemek oldukça kolaydır.

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

var x: Boolean? = null

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

Bir containüzerinde benzer işlemler yapmak istiyorsanız, Stringaşağıdaki gibi eşitlik kontrolünü kullanabilirsiniz -

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

Güvenli Operatör "izin ver" ile yapabilirsiniz

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