Kotlin'de aşağıdaki Swift kodunun bir eşdeğeri var mı?

if let a = b.val {

}
else {

}

let-İşlevini şu şekilde kullanabilirsiniz :

val a = b?.let {
    // If b is not null.
} ?: run {
    // If b is null.
}

runYalnızca bir kod bloğuna ihtiyacınız olduğunda işlevi aramanız gerektiğini unutmayın . run-Block'u, yalnızca elvis-operator ( ?:) ' den sonra bir onelineriniz varsa kaldırabilirsiniz .

Unutmayın runblok halinde ya değerlendirilecektir bnull veya eğer let-blok- değerlendirir için null.

Bu nedenle, genellikle sadece bir ififade istersiniz .

val a = if (b == null) {
    // ...
} else {
    // ...
}

Bu durumda, else-block yalnızca bboş değilse değerlendirilecektir .

Öncelikle, sağlanan Swift deyiminin anlamını anladığımızdan emin olalım:

if let a = <expr> {
     // then-block
}
else {
     // else-block
}

Bunun anlamı şudur : "Eğer <expr>sonuç sıfır olmayan bir isteğe bağlı sonuç thenverirse a, sarılmamış değere bağlı sembol ile -block girin. Aksi takdirde elsebloğu girin .

Özellikle bunun yalnızca -block içindea bağlı olduğuna dikkat edin . Kotlin'de bunu arayarak kolayca alabilirsinizthen

<expr>?.also { a ->
    // then-block
}

ve elsebunun gibi bir -block ekleyebilirsiniz :

<expr>?.also { a ->
    // then-block
} ?: run {
    // else-block
}

Bu, Swift deyimiyle aynı anlambilimle sonuçlanır.

Cevabım tamamen diğerlerinden kopya bir kedi. Ancak ifadelerini kolayca anlayamıyorum. Bu yüzden daha anlaşılır bir cevap vermek güzel olurdu sanırım.

Hızlı olarak:

if let a = b.val {
  //use "a" as unwrapped
}
else {

}

Kotlin'de:

b.val?.let{a -> 
  //use "a" as unwrapped
} ?: run{
  //else case
}

Swift'in aksine, İsteğe bağlı olanı Kotlin'de kullanmadan önce açmak gerekli değildir. Değerin boş olup olmadığını kontrol edebiliriz ve derleyici yaptığınız kontrol hakkındaki bilgileri izler ve onu paketlenmemiş olarak kullanmaya izin verir.

Swift'de:

if let a = b.val {
  //use "a" as unwrapped
} else {

}

Kotlin'de:

if b.val != null {
  //use "b.val" as unwrapped
} else {

}

Bu tür daha fazla kullanım durumu için Dokümantasyona bakın : (null-security)

if let Beyan.

Swift'in Optional Binding(sözde if-letifade), isteğe bağlı bir değer içerip içermediğini bulmak ve eğer öyleyse, bu değeri geçici bir sabit veya değişken olarak kullanılabilir hale getirmek için kullanılır. Yani, bir Optional Bindingiçin if-letaşağıdaki gibidir açıklamada ise:

Swift'in if-letaçıklaması:

let b: Int? = 50

if let a = b {
    print("Good news!")
} else {
    print("Equal to 'nil' or not set")
}

/*  RESULT: Good news!  */

Kotlin'de, Swift'de olduğu gibi, beklenmediğinde boş bir değere erişmeye çalışmanın neden olduğu çökmeleri önlemek b.let { }için, düzgün bir şekilde sarmalama için belirli bir sözdizimi ( ikinci örnekte olduğu gibi) sağlanır nullable types:

Kotlin eşdeğeri Swift'in if-letifadesinin 1'i :

val b: Int? = null
val a = b

if (a != null) { 
    println("Good news!")
} else { 
    println("Equal to 'null' or not set")
}

/*  RESULT: Equal to 'null' or not set  */

Kotlin'in letişlevi, güvenli arama operatörü ile birlikte kullanıldığında, ?:boş değer atanabilir ifadeleri işlemek için kısa bir yol sağlar.

Swift'in ifadesinin Kotlin eşdeğeri 2 (Inline let function ve Elvis Operator)if-let :

val b: Int? = null

val a = b.let { nonNullable -> nonNullable } ?: "Equal to 'null' or not set"
println(a)

/*  RESULT: Equal to 'null' or not set  */

guard let Beyan.

guard-letSwift'deki ifade basit ve güçlüdür. Bazı koşulları kontrol eder ve yanlış olarak değerlendirilirse, elsenormalde bir yöntemden çıkacak olan ifade yürütülür.

Bir Swift'in guard-letifadesini inceleyelim:

let b: Int? = nil

func testIt() {
    guard let a = b else {
        print("Equal to 'nil' or not set")
        return
    }
    print("Good news!")
}
testIt()

/*  RESULT: Equal to 'nil' or not set  */

Kotlin'in Swift'in guard-letaçıklamasına benzer etkisi :

Swift'in aksine, Kotlin'de hiçbir koruma ifadesi yok . Bununla birlikte, benzer bir efekt elde etmek için Elvis Operator- kullanabilirsiniz ?:.

val b: Int? = 50

fun testIt() {
    val a = b ?: return println("Equal to 'null' or not set")
    return println("Good news!")
}
testIt()

/*  RESULT: Good news!  */

Bu yardımcı olur umarım.

Yalnızca nameboş olmadığında kodun nasıl çalıştırılacağı aşağıda açıklanmıştır :

var name: String? = null
name?.let { nameUnwrapp ->
    println(nameUnwrapp)  // not printed because name was null
}
name = "Alex"
name?.let { nameUnwrapp ->
    println(nameUnwrapp)  // printed "Alex"
}

İşte benim varyantım, çok yaygın olan "boş değilse" durumla sınırlı.

Her şeyden önce, bunu bir yerde tanımlayın:

inline fun <T> ifNotNull(obj: T?, block: (T) -> Unit) {
    if (obj != null) {
        block(obj)
    }
}

internalÇatışmalardan kaçınmak için muhtemelen olmalı .

Şimdi, bu Swift kodunu dönüştürün:

if let item = obj.item {
    doSomething(item)
}

Bu Kotlin koduna:

ifNotNull(obj.item) { item -> 
    doSomething(item)
}

Kotlin'deki bloklarda her zaman olduğu gibi, argümanı bırakıp şunları kullanabileceğinizi unutmayın it:

ifNotNull(obj.item) {
    doSomething(it)
}

Ancak blok 1-2 satırdan fazlaysa, muhtemelen açık olmak en iyisidir.

Bu bulabildiğim kadar Swift'e benziyor.

Swift'in if-let tarzına ulaşmak için kotlin'de benzer bir yol var

if (val a = b) {
    a.doFirst()
    a.doSecond()
}

Ayrıca birden çok null atanabilir değer atayabilirsiniz

if (val name = nullableName, val age = nullableAge) {
    doSomething(name, age)
}

Bu tür bir yaklaşım, null yapılabilir değerler 1 defadan fazla kullanılırsa daha uygun olacaktır. Bence performans açısından yardımcı oluyor çünkü boş değer atanabilir değer yalnızca bir kez kontrol edilecek.

kaynak: Kotlin Tartışması

Bu yanıtı, yorum için çok büyük olduğu için kabul edilen yanıtı netleştirmek için ekliyorum.

Buradaki genel model , Kotlin'de mevcut olan Kapsam İşlevlerinin herhangi bir kombinasyonunu Elvis Operatörü tarafından şu şekilde ayrılmış olarak kullanabilmenizdir :

<nullable>?.<scope function> {
    // code if not null
} :? <scope function> {
    // code if null
}

Örneğin:

val gradedStudent = student?.apply {
    grade = newGrade
} :? with(newGrade) {
    Student().apply { grade = newGrade }
}

Bence en temiz seçenek bu

Swift:

if let a = b.val {

} else {

}

Kotlin

b.val.also { a ->

} ?: run {

}

Swift, Kotlin'de ifade ederse

Kısa cevap, basit IF-ELSE kullanmaktır, çünkü bu yorumun zamanına kadar Kotlin LET'te eşdeğeri yoktur,

    if(A.isNull()){
// A is null
    }else{
// A is not null
    }