Kotlin Opérateur Conditionnel Ternaire

vous pouvez définir votre propre Boolean fonction d'extension qui retourne null lorsque le Boolean est false pour fournir une structure similaire à l'opérateur ternaire:

infix fun <T> Boolean.then(param: T): T? = if (this) param else null

cela ferait une expression a ? b : c traduire en a then b ?: c , comme ainsi:

println(condition then "yes" ?: "no")

mise à Jour: Mais pour faire plus Java-like conditional switch vous aurez besoin de quelque chose comme cela

infix fun <T> Boolean.then(param: () -> T): T? = if (this) param() else null

println(condition then { "yes" } ?: "no") faites attention à la lambda. son calcul de contenu doit être reporté jusqu'à ce que nous nous assurons que condition est true

celui-ci a l'air maladroit, c'est pourquoi il ya haute demande demandée existent pour port opérateur ternaire Java dans Kotlin

pour moi j'utilise les fonctions d'extension suivantes:

fun T?.or<T>(default: T): T = if (this == null) default else this 
fun T?.or<T>(compute: () -> T): T = if (this == null) compute() else this

le premier retournera la valeur par défaut fournie dans le cas où l'objet est égal à null. La seconde évaluera l'expression fournie dans lambda dans le même cas.

Utilisation:

1) e?.getMessage().or("unknown")
2) obj?.lastMessage?.timestamp.or { Date() }

personnellement pour moi code ci-dessus plus lisible que if construction inlining

Dans Kotlin, if est une expression, c'est à dire qu'elle renvoie une valeur. Donc il n'y a pas d'opérateur ternaire (condition ? then : else) , car ordinaire si fonctionne très bien dans ce rôle. source manuelle d'ici

// Traditional usage 
var max = a 
if (a < b) max = b

// With else 
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}

// As expression 
val max = if (a > b) a else b

Il y a aucun opérateur ternaire dans kotlin, comme le if else bloc renvoie la valeur

, vous pouvez faire: val max = if (a > b) a else b au lieu de java max = (a > b) ? b : c

nous pouvons également utiliser when construction, Il valeur de retour aussi:

val max = when(a > b) {
    true -> a
    false -> b
}

voici le lien pour la documentation de kotlin: flux de contrôle: si, quand, pendant, tandis que

regardez le docs :

Dans Kotlin, si est une expression, c'est à dire qu'elle renvoie une valeur. Par conséquent, il pas d'opérateur ternaire (condition ? alors : d'autre), parce que ordinaire si fonctionne bien dans ce rôle.

certains cas corner non mentionnés dans d'autres réponses.

depuis l'apparition de takeIf dans Kotlin 1.1 l'opérateur ternaire a ? b : c peut également être exprimé comme ceci:

b.takeIf { a } ?: c

cela devient encore plus court dans le cas c est null :

b.takeIf { a }

également noter que typique dans le monde Java null chèques comme value != null ? value : defaultValue traduire en Kotlin idéomatique à juste value ?: defaultValue .

similaire a != null ? b : c peut être traduit en a?.let { b } ?: c .

Kotlin a des Expressions

dans Kotlin, de nombreuses déclarations de contrôle dont if , when ou même try peuvent être utilisées comme expressions . Cela signifie qu'ils ont un résultat et peuvent être assignés à une variable, retournés à partir d'une fonction, etc.

syntactiquement, pas besoin d'opérateur ternaire

ayant dit cela, Kotlin n'a pas besoin de l'opérateur ternaire .

if (a) b else c est ce que vous pouvez utiliser à la place de L'expression Java a ? b : c .

je pense que l'idée est que ce dernier est moins lisible puisque tout le monde sait ce que ifelse fait, alors que ? : est plutôt incommode si vous n'êtes pas familiar avec la syntaxe déjà. Bien que je doive admettre que je manque souvent l'opérateur ternaire plus commode.

Autres Alternatives

quand

vous pourriez également voir un lot when constructions chaque fois que les conditions sont vérifiées dans Kotlin. C'est aussi une façon d'exprimer SI-AUTREMENT cascades d'une manière alternative. La suite correspond à votre exemple.

when(a) {
    true -> b
    false -> c
}

Extensions

Comme beaucoup de bons exemples ( Kotlin Opérateur Conditionnel Ternaire ) dans les autres réponses montrent, les extensions peuvent également être un moyen d'aller.

Java

int temp = a ? b : c;

équivalent de Kotlin"

var temp = if (a) b else c

remplace l'opérateur de commutateur des langages de type C. Dans la forme la plus simple, il ressemble à ceci

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("x is neither 1 nor 2")
    }
}

il n'y a pas d'opérateur ternaire à Kotlin. Cela semble problématique à première vue. Mais pense que nous pouvons le faire avec inline Si autre déclaration parce que c'est l'expression ici. Tout simplement nous devons faire -

var number = if(n>0) "Positive" else "Negetive"

ici, on peut faire autrement si on en bloque trop. Comme -

var number = if(n>0) "Positive" else if(n<0) "Negative" else "Zero"

donc cette ligne est si simple et beaucoup plus lisible que l'opérateur ternaire. lorsque nous utilisons plus d'un opérateur ternaire en java, il semble horrible. Mais ici, nous avons un clair de la syntaxe. même on peut l'écrire en plusieurs ligne trop.

comme Drew Noakes Cité, kotlin utiliser si la déclaration comme expression, opérateur conditionnel ternaire N'est plus nécessaire,

mais avec la fonction extension et la surcharge infix, vous pouvez mettre en œuvre vous-même, voici un exemple

infix fun <T> Boolean.then(value: T?) = TernaryExpression(this, value)

class TernaryExpression<out T>(val flag: Boolean, val truly: T?) {
    infix fun <T> or(falsy: T?) = if (flag) truly else falsy
}

alors utilisez - le comme ceci

val grade = 90
val clazz = (grade > 80) then "A" or "B"

une Autre approche intéressante serait d'utiliser when :

when(a) {
  true -> b
  false -> b
}

peut être très pratique dans certains scénarios plus complexes. Et honnêtement, c'est plus lisible pour moi que if ... else ...

Vous pouvez faire beaucoup de chemin dans Kotlin

1. utilisant if

   if(a) b else c
   

2. en utilisant "quand

   when (a) { 
       true -> print("value b") 
       false -> print("value c") 
       else -> {  
           print("default return in any other case") 
       } 
   }
   

3. Sécurité Nulle

   val a = b ?: c
   

il n'y a pas d'opérateur ternaire à Kotlin, car il y a l'expression if:

var d = if (a) b else c

selon la documentation de Kotlin pour moi-même, j'utilise le code suivant:

 val max = if (a > b) a else b

et:

when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  else -> { // Note the block
      print("x is neither 1 nor 2")
  }
}

si vous voulez en savoir plus, cliquez sur le lien suivant: flux de contrôle: si, quand, pendant, tandis que

vous pouvez utiliser l'expression if pour cela dans Kotlin. En Kotlin if est une expression avec une valeur de résultat. Donc à Kotlin on peut écrire

fun max(a: Int, b: Int) = if (a > b) a else b

et en Java nous pouvons obtenir le même mais avec un code plus grand

int max(int a, int b) {
return a > b ? a : b
}

il n'y a pas d'opération ternaire à Kotlin, mais il y a des façons amusantes de contourner cela. Comme d'autres l'ont fait remarquer, une traduction directe en Kotlin ressemblerait à ceci:

val x = if (condition) result1 else result2

Mais, personnellement, je pense que cela peut être un peu encombré et difficile à lire. Il y a d'autres options intégrées dans la bibliothèque. Vous pouvez utiliser takeIf {} avec un opérateur elvis:

val x = result1.takeIf { condition } ?: result2

ce qui se passe là - bas est que le takeIf { } commande renvoie soit votre result1 ou nulle, et la elvis opérateur gère la null. Il y a d'autres options, takeUnless { }, par exemple:

val x = result1.takeUnless { condition } ?: result2

le langage est clair, vous savez ce que ça fait.

si c'est une condition couramment utilisée, Vous pouvez également faire quelque chose d'amusant comme l'utilisation d'une méthode d'extension en ligne. Supposons que nous voulons suivre un score de jeu comme un Int, par exemple, et nous voulons toujours retourner 0 si un condition n'est pas remplie:

inline fun Int.zeroIfFalse(func: () -> Boolean) : Int = if (!func.invoke()) 0 else this     

Ok, ça a l'air moche. Mais pensez à l'apparence quand il est utilisé:

var score = 0
val twoPointer = 2
val threePointer = 3

score += twoPointer.zeroIfFalse { scoreCondition } 
score += threePointer.zeroIfFalse { scoreCondition } 

comme vous pouvez le voir, Kotlin offre beaucoup de flexibilité dans la façon dont vous choisissez d'exprimer votre code. Il y a d'innombrables variantes de mes exemples et probablement des façons que je n'ai pas encore découvertes. J'espère que cela aide!

une Autre approche

val value : String = "Kotlin"

value ?: ""

ici kotlin lui-même vérifie la valeur nulle et si elle est nulle alors elle passe la valeur de chaîne vide.

pourquoi utiliserait-on quelque chose comme ceci:

when(a) {
  true -> b
  false -> b
}

quand vous pouvez réellement utiliser quelque chose comme ceci ( a est booléen dans ce cas):

when {
  a -> b
  else -> b
}

à Kotlin, il y a sans opérateur ternaire .

Dans Kotlin, si est une expression, c'est à dire qu'elle renvoie une valeur.

il N'y a donc pas d'opérateur ternaire (condition ? alors : d'autre), parce que ordinaire si fonctionne bien dans ce rôle.

équivalent en Kotlin

var a = if (a) b else c

document de référence : Débit de commande: si, quand, pendant, tandis que

avec les fonctions infix suivantes, je peux couvrir de nombreux cas d'utilisation commune à peu près de la même manière que cela peut être fait en Python:

class TestKotlinTernaryConditionalOperator {

    @Test
    fun testAndOrInfixFunctions() {
        Assertions.assertThat(true and "yes" or "no").isEqualTo("yes")
        Assertions.assertThat(false and "yes" or "no").isEqualTo("no")

        Assertions.assertThat("A" and "yes" or "no").isEqualTo("yes")
        Assertions.assertThat("" and "yes" or "no").isEqualTo("no")

        Assertions.assertThat(1 and "yes" or "no").isEqualTo("yes")
        Assertions.assertThat(0 and "yes" or "no").isEqualTo("no")

        Assertions.assertThat(Date() and "yes" or "no").isEqualTo("yes")
        @Suppress("CAST_NEVER_SUCCEEDS")
        Assertions.assertThat(null as Date? and "yes" or "no").isEqualTo("no")
    }
}

infix fun <E> Boolean?.and(other: E?): E? = if (this == true) other else null
infix fun <E> CharSequence?.and(other: E?): E? = if (!(this ?: "").isEmpty()) other else null
infix fun <E> Number?.and(other: E?): E? = if (this?.toInt() ?: 0 != 0) other else null
infix fun <E> Any?.and(other: E?): E? = if (this != null) other else null
infix fun <E> E?.or(other: E?): E? = this ?: other

utiliser soit if-else conditional statement soit when operator comme suit""

when(a) {
  true -> b
  false -> b
}

il n'y a pas d'opérateur ternaire à Kotlin, les plus fermés sont les deux cas ci-dessous,

• Si d'autre que l'expression de l'énoncé

val a = true if(a) print("A is true") else print("A is false")

• Elvis opérateur

si l'expression à gauche de ?: n'est pas null, la elvis opérateur retourne, sinon elle renvoie l'expression à droite. Note que le côté droit de l'expression est évaluée uniquement si la gauche side est nul.

 val name = node.getName() ?: throw IllegalArgumentException("name expected")

"1519210920 Référence de" docs

exemple: var énergie: Int = données?.get (position)?.de l'énergie?.toInt ()?: 0

à kotlin si vous utilisez ?: cela fonctionnera comme si l'instruction return null, ?: 0 il faudra 0 ou ce que vous avez à écrire ce côté.

quand on travaille avec apply (), il semble très pratique quand on travaille avec des opérations ternaires, car il est plus élégant et vous donne de la place

val columns: List<String> = ...
val band = Band().apply {
    name = columns[0]
    album = columns[1]
    year = columns[2].takeIf { it.isNotEmpty() }?.let { it.toInt() } ?: 0
}