Swift si let déclaration à Kotlin

Question

Dans Kotlin, existe-t-il un équivalent du code Swift ci-dessous?

 if let a = b.val {

}
else {

}
 

Answer 1

Vous pouvez utiliser l' let-fonction comme ceci:

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

Notez que vous devez appeler l' run fonctionner que si vous avez besoin d'un bloc de code. Vous pouvez supprimer l' run-bloc si vous avez seulement un oneliner après la elvis-opérateur (?:).

Être conscient que l' run bloc sera évaluée soit si b est null, ou si l' let-bloc retourne null.

De ce fait, habituellement, vous voulez juste un if expression.

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

Dans ce cas, l' else-bloc sera évaluée uniquement si b a la valeur null.

Answer 2

Nous allons tout d'abord nous assurer de comprendre la sémantique de la condition Swift idiome:

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

Il signifie ceci: "si l' <expr> non néant en option, entrez le then-bloc avec le symbole a lié à la déballé valeur. Autrement, dans l' else bloc.

Remarque surtout qu' a est lié uniquement à l'intérieur de l' then-bloc. Dans Kotlin vous pouvez facilement l'obtenir en appelant

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

et vous pouvez ajouter un else-bloc comme ceci:

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

Il en résulte la même sémantique que le Swift idiome.

Answer 3

Ma réponse est totalement une copie de chat des autres. Cependant, je ne peux pas comprendre leur expression facilement. Je pense donc que ce serait bien de fournir une réponse plus compréhensible.

En rapide:

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

}
 

À Kotlin:

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

Answer 4

if let déclaration.

Swift Optional Binding (soi-disant if-let déclaration) est utilisé pour savoir si une option contient une valeur, et si oui, à faire la valeur de la disposition, à titre temporaire, constante ou variable. Ainsi, une Optional Binding de la if-let déclaration est comme suit:

Swift if-let déclaration:

let b: Int? = 50

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

/*  RESULT: Good news!  */

Dans Kotlin, comme dans Swift, pour éviter les accidents causés par une tentative d'accès à un valeur null quand il n'est pas prévu, une syntaxe spécifique (comme b.let { } dans le second exemple) est prévue pour le déballage nullable types:

Kotlin l'équivalent de 1 de Swift if-let déclaration:

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 de l' let fonction, lorsqu'il est utilisé en combinaison avec le coffre-appeler l'opérateur ?:, fournit une manière concise pour gérer nullable expressions.

Kotlin l'équivalent de 2 (Inline laissez fonction et Elvis Opérateur) de Swift if-let déclaration:

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 déclaration.

guard-let déclaration Swift est simple et puissant. Il vérifie une certaine condition et si on les évalue à false, alors l' else exécution d'une instruction qui est généralement à la sortie d'une méthode.

Nous allons explorer une Swift guard-let déclaration:

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 le même effet de Swift guard-let déclaration:

Contrairement à Swift, dans Kotlin, il n'y a pas de garde instruction à tous. Toutefois, vous pouvez utiliser l' Elvis Operator – ?: pour obtenir un effet similaire.

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

Espérons que cette aide.

Answer 5

Voici comment exécuter du code uniquement lorsque name n'est pas 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"
}