В Котлине есть эквивалент кода Swift ниже?
if let a = b.val {
}
else {
}
В Котлине есть эквивалент кода Swift ниже?
if let a = b.val {
}
else {
}
Вы можете использовать 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.
Давайте сначала убедимся, что мы понимаем семантику предоставленной идиомы 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.
Мой ответ - полностью копия кошки от других. Однако я не могу легко понять их выражение. Поэтому я думаю, что было бы неплохо дать более понятный ответ.
В скором времени:
if let a = b.val {
//use "a" as unwrapped
}
else {
}
В Котлине:
b.val?.let{a ->
//use "a" as unwrapped
} ?: run{
//else case
}
Здесь как выполнять код только тогда, когда 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"
}
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! */
Надеюсь, это поможет.
В отличие от Swift, необязательно разворачивать опциональное перед использованием в Kotlin. Мы могли бы просто проверить, является ли значение ненулевым, и компилятор отслеживает информацию о выполненной вами проверке и позволяет использовать ее как развернутую.
В Свифте:
if let a = b.val {
//use "a" as unwrapped
} else {
}
В Котлине:
if b.val != null {
//use "b.val" as unwrapped
} else {
}
Обратитесь к Документации: (ноль-безопасность) для большего количества таких случаев использования
Вот мой вариант, ограниченный очень распространенным случаем "если не ноль".
Прежде всего, определите это где-нибудь:
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, как я мог найти.
В 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 Дискуссия