你可以像这样使用let函数:

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

注意，只有在需要代码块时才需要调用run函数。如果你在elvis操作符(?:)后面只有一个线性程序，你可以删除运行块。

注意，如果b为空，或者let-block为空，则运行块将被求值。

因此，您通常只需要一个if表达式。

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

在这种情况下，只有当b不为空时，else块才会被计算。

让我们首先确保我们理解了所提供的Swift习语的语义:

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

它的意思是:“如果<expr>结果为非nil可选，则输入then块，并将符号a绑定到未包装的值。否则进入else块。

特别注意，a只在then块内绑定。在Kotlin中，您可以通过调用很容易地得到这个

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

你可以像这样添加一个else-block:

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

这将导致与Swift习惯用法相同的语义。

下面是如何只在name不为空时执行代码:

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

在kotlin中也有类似的方法来实现Swift的if-let风格

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

您还可以分配多个可空值

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

如果可空值被使用超过1次，这种方法将更适合。在我看来，它从性能方面有所帮助，因为可为空的值将只检查一次。

来源:Kotlin Discussion

我的答案完全是抄袭别人的。但是，我不容易理解他们的表情。所以我想提供一个更容易理解的答案会很好。

迅速:

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

}

在芬兰湾的科特林:

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

与Swift不同的是，在Kotlin中使用它之前，不需要打开可选选项。我们可以检查该值是否为非空，编译器会跟踪您执行的检查信息，并允许将其作为解包装使用。

迅速:

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

}

在芬兰湾的科特林:

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

}

更多这样的用例请参考Documentation:(null-safety)

If let语句

Swift if let可选绑定(称为if-let语句)用于提取存在的非可选值，或者如果值为nil则不执行任何操作。

斯威夫特的if-let声明:

let b: Int? = 50

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

/*  RESULT: Good news!  */

在Kotlin中，就像在Swift中一样，为了避免在不期望的情况下试图访问空值而导致的崩溃，提供了一个特定的语法(如第二个例子中的b.let{})来正确地展开可空类型:

Kotlin相当于Swift的if-let语句:

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的let方法与安全调用操作符?:结合使用时，提供了一种处理可空表达式的简洁方法。

Kotlin的内联let函数和Swift的nil合并运算符的Elvis运算符:

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

警卫让声明

Swift中的guard-let语句简单而强大。它检查某些条件，如果计算结果为false，则执行else语句，该语句通常会退出一个方法。

让我们来看看斯威夫特的这句话:

let b: Int? = nil

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

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

Kotlin对霉霉的保守声明也有类似的影响:

与Swift不同的是，在Kotlin中根本没有警卫声明。但是，您可以使用Elvis Operator - ?:来获得类似的效果。

val b: Int? = 50

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

/*  RESULT: Good news!  */

这是我的变体，仅限于非常常见的“if not null”情况。

首先，在某个地方定义它:

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

它可能应该是内部的，以避免冲突。

现在，转换这个Swift代码:

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

到这个Kotlin代码:

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

请注意，在Kotlin中，你可以删除参数并使用它:

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

但是如果代码块超过1-2行，最好是显式的。

这是我所能找到的最相似的斯威夫特。

我添加这个答案是为了澄清已接受的答案，因为它太大了，不适合评论。

这里的一般模式是，你可以使用Kotlin中可用的范围函数的任何组合，由Elvis操作符分隔，如下所示:

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

例如:

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

在我看来，最干净的选择是这样的

迅速:

if let a = b.val {

} else {

}

科特林

b.val.also { a ->

} ?: run {

}

Swift如果让声明在Kotlin

简短的回答是使用简单的IF-ELSE，因为在这篇评论的时候，在Kotlin LET中没有等效的东西，

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

上面有两个答案，都得到了很多人的接受:

str ?。让{}?:运行{} str ?。还有{}?:run {}

两者似乎都适用于大多数用法，但#1在下面的测试中会失败:

第二条似乎更好。

如果让我们使用内联的乐趣，我们可以得到像Swift一样的unwring语法

inline fun <T:Any?> T?.unwrap(callback: (T)-> Unit) : Boolean {
    return if (this != null) {
        this?.let(callback)
        true
    }else {
        false
    }
}

用途::

        val  name : String? = null
        val  rollNo : String? = ""
        var namesList: ArrayList<String>?  = null

        if (name.unwrap { name ->

                Log.i("Dhiru", "Name have value on it  $name")

            })else if ( rollNo.unwrap {
                Log.i("Dhiru","Roll have value on it")

            }) else if (namesList.unwrap {  namesList  ->
                Log.i("Dhiru","This is Called when names list have value ")
            })  {
             Log.i("Dhiru","No Field have value on it ")
        }

如果b是一个成员变量，那么这种方法对我来说似乎是最有可读性的:

val b = this.b
if (b == null) {
    return
}
println("non nullable : ${b}")

这也与它在swift中的工作方式一致，在swift中，一个新的局部变量遮蔽了成员变量。

Any的问题是什么?让{}?:运行{}结构是:

它只允许每条语句进行一次非空检查 如果let块返回null，运行块无论如何都会被求值 不可能在switch/when样式中执行多次检查

解决这些问题的一个解决方案是定义如下的函数:

private inline fun <A> ifNotNull(p1: A?, block: (A) -> Unit): Unit? {
    if (p1 != null) {
        return block.invoke(p1)
    }
    return null
}

private inline fun <A, B> ifNotNull(p1: A?, p2: B?, block: (A, B) -> Unit): Unit? {
    if (p1 != null && p2 != null) {
        return block.invoke(p1, p2)
    }
    return null
}

private inline fun <A, B, C> ifNotNull(p1: A?, p2: B?, p3: C?, block: (A, B, C) -> Unit): Unit? {
    if (p1 != null && p2 != null && p3 != null) {
        return block.invoke(p1, p2, p3)
    }
    return null
}

这将允许这样的语句:

ifNotNull(a, b) { a, b ->
    // code when a, b are not null
} ?:
ifNotNull(c) { c ->
    // code when a, b are null and c not null
} ?: 
ifNotNull(d, e, f) { d, e, f ->
    // code when a, b, c are null and d, e, f not null
} ?: run {
    // code which should be performed if a, b, c, d, e and f are null
}

唯一需要注意的是，与Swift的if let相比，如果在循环中执行，则不支持continue和break语句。

也许我已经很晚了，但最简单的方法是打开和选择

yourOptionalString ?: return

这是下面的所有行都将有解开的字符串