Ответ 1

Вы можете использовать let -function следующим образом:

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

Обратите внимание, что вам нужно вызвать функцию run только если вам нужен блок кода. Вы можете удалить run -block, если у вас есть только oneliner после оператора elvis (?: :).

Имейте в виду, что run блока будет оцениваться либо, если b равна нулю, или если let -block вычисляется в null.

Из-за этого вам обычно требуется только выражение if.

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

В этом случае else -block будет оцениваться только в том случае, если b равно null.

Ответ 2

Давайте сначала убедимся, что мы понимаем семантику предоставленной идиомы Swift:

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

Это означает, что это: "если <expr> приводит к не-нолю по желанию, введите then -block с символом связанным с развернутым значением В противном случае введите. a else блок.

Особо отметим, что a связан только в пределах then -block. В Kotlin вы можете легко получить это, позвонив

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

и вы можете добавить else -block, как это:

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

Это приводит к той же семантике, что и идиома Swift.

Ответ 3

Мой ответ - полностью копия кошки от других. Однако я не могу легко понять их выражение. Поэтому я думаю, что было бы неплохо дать более понятный ответ.

В скором времени:

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

}

В Котлине:

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

Ответ 4

Здесь как выполнять код только тогда, когда name не равно null:

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

Ответ 5

if let выражение.

Swift Optional Binding (так называемый оператор if-let) используется, чтобы выяснить, содержит ли необязательное значение значение, и если да, сделать это значение доступным в качестве временной константы или переменной. Итак, Optional Binding для оператора if-let выглядит следующим образом:

Swift if-let statement:

let b: Int? = 50

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

/*  RESULT: Good news!  */

В Kotlin, как и в Swift, чтобы избежать сбоев, вызванных попыткой получить доступ к нулевому значению, когда оно не ожидается, для правильного развертывания предусмотрен специальный синтаксис (например, b.let { } во втором примере) nullable types:

Kotlin equivalent 1 of Swift if-let statement:

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  */

Функция Kotlins let, используемая в сочетании с оператором безопасного вызова ?:, обеспечивает краткий способ обработки выражений, допускающих обнуляемость.

Kotlin equivalent 2 (Inline let function и Elvis Operator) of Swift if-let statement:

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 выражение.

guard-let утверждение в Swift простое и мощное. Он проверяет некоторые условия и, если он оценивается как ложный, выполняется оператор else, который обычно завершает работу метода.

Давайте рассмотрим утверждение Swift guard-let:

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 similar effect of Swift guard-let statement:

В отличие от Swift, в Котлине нет охранного заявления вообще. Однако вы можете использовать Elvis Operator - ?: для получения аналогичного эффекта.

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!  */

Надеюсь, это поможет.

Ответ 6

В отличие от Swift, необязательно разворачивать опциональное перед использованием в Kotlin. Мы могли бы просто проверить, является ли значение ненулевым, и компилятор отслеживает информацию о выполненной вами проверке и позволяет использовать ее как развернутую.

В Свифте:

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

}

В Котлине:

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

}

Обратитесь к Документации: (ноль-безопасность) для большего количества таких случаев использования

Ответ 7

Вот мой вариант, ограниченный очень распространенным случаем "если не ноль".

Прежде всего, определите это где-нибудь:

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

Вероятно, это должен быть internal, чтобы избежать конфликтов.

Теперь преобразуйте этот код Swift:

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

Для этого кода Kotlin:

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

Обратите внимание, что, как всегда с блоками в Kotlin, вы можете отбросить аргумент и использовать it:

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

Но если в блоке больше 1-2 строк, вероятно, лучше всего быть явным.

Это так же похоже на Swift, как я мог найти.

Ответ 8

В kotlin есть аналогичный способ достижения стиля Swift if-let

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

Вы также можете назначить несколько обнуляемых значений

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

Такой подход будет более подходящим, если обнуляемые значения используются более 1 раза. На мой взгляд, это помогает с точки зрения производительности, потому что значение Nullable будет проверено только один раз.

источник: Kotlin Дискуссия