web-dev-qa-db-fra.com

Swift si let déclaration à Kotlin

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

if let a = b.val {

}
else {

}
swiftkotlin
72
iori24

Vous pouvez utiliser la fonction let- comme ceci:

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

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

Sachez que le bloc run sera évalué si b est null ou si le let- block est évalué à null.

Pour cette raison, vous voulez généralement juste une expression if.

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

Dans ce cas, le bloc else- ne sera évalué que si b est null.

149
marstran

Veillons d'abord à bien comprendre la sémantique de l'idiome Swift fourni:

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

Cela signifie: "si le <expr> donne un non-nil optionnel, entrez le bloc then- avec le symbole a lié à la valeur non enveloppée. Sinon, entrez le bloc else.

Notez en particulier que a est lié uniquement dans le then- block . À Kotlin, vous pouvez facilement obtenir cela en appelant

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

et vous pouvez ajouter un bloc else- comme ceci:

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

Cela donne la même sémantique que l'idiome Swift. Cependant, il y a toujours une différence dans le cas où vous voudriez traiter l'idiome entier comme une expression et récupérer son résultat, ainsi dans Swift:

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

Si result est d'un type non optionnel, vous pouvez utiliser cet idiome:

val result = <expr>?.let { a ->
    // then-block
} ?: run {
    // else-block
}

Cela fonctionne de manière indirecte: nous calculons une valeur non nulle, donc <expr>?.let {...} évaluant à null signifie <expr> évalué à null. 

Pour le cas tout à fait général qui fonctionne pour des résultats nullables, je ne pouvais pas trouver un moyen naturel de l'exprimer dans Kotlin sans laisser a au périmètre situé en dehors du bloc then-.

22
Marko Topolnik

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"
}
4
Александр Яковенко

Contrairement à Swift, il n'est pas nécessaire de déballer l'option avant de l'utiliser dans Kotlin. Nous pourrions simplement vérifier si la valeur est non nulle et si le compilateur suit les informations sur le contrôle que vous avez effectué et permet de l’utiliser comme non-enveloppé.

En rapide:

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

}

À Kotlin:

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

}

Référez-vous Documentation: (null-safety) pour plus de cas d'utilisation

2
Shahzin KS

Ma réponse est totalement une copie de chat des autres. Cependant, je ne peux pas comprendre leur expression facilement. Je suppose 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
}
0
Wu Yuan Chun

déclaration if let.

L'attribut Optional Binding de Swift (ainsi appelé instruction if-let) permet de déterminer si un facultatif contient une valeur et, le cas échéant, de rendre cette valeur disponible sous forme de constante ou de variable temporaire. Ainsi, un Optional Binding pour l'instruction if-let est le suivant: 

L'instruction if-let de Swift:

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 plantages causés par la tentative d’accès à une valeur nulle alors qu’elle n’était pas attendue, une syntaxe spécifique (telle que b.let { } dans le deuxième exemple) est fournie pour décompresser correctement nullable types:

Équivalent Kotlin 1 de l'instruction if-let de Swift:

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

La fonction let de Kotlin, lorsqu'elle est utilisée en combinaison avec l'opérateur ?: de l'appel sécurisé, fournit un moyen concis de gérer les expressions nullables.

Équivalent Kotlin 2 _ ​​(Fonction let inline et opérateur Elvis)} de l'instruction if-let de Swift:

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

 enter image description here

déclaration guard let.

L'instruction guard-let dans Swift est simple et puissante. Il vérifie la présence d'une condition et, s'il est faux, l'instruction else est exécutée et permet normalement de quitter une méthode.

Explorons l'instruction guard-let de Swift:

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

Effet similaire de Kotlin de l'instruction guard-let de Swift:

Contrairement à Swift, dans Kotlin, il n’ya aucune déclaration de guard. Cependant, vous pouvez utiliser le 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!  */

J'espère que cela t'aides.

0
ARGeo