Kotlin ignore l'expression

Question

Je me demande pourquoi le code ci-dessous génère des résultats étranges, alors que le compilateur n'affiche aucune erreur ou avertissement. Cela semble être une source de bogues extrêmement efficace.

    val a = 10 * 20 +
            10 * 30

    val b = 10 * 20
          + 10 * 30

    val c = (
               (10 * 20)
             + (10 * 30)
            )

    val d = (10 * 20)
          + (10 * 30)

    println(a)
    println(b)
    println(c)
    println(d)

Et le résultat est le suivant :

500
200
500
200

Answer 1

Kotlin a des points-virgules optionnels, il permet et encourage le code source à omettre un séparateur d'énoncé (c'est-à-dire un point-virgule ; ). Par conséquent, le compilateur peut avoir du mal à deviner ce que vous, en tant que programmeur, avez réellement l'intention de faire :

val b = 10 * 20
       + 10 * 30

Sera compilé à une affectation de b = 500 et une deuxième déclaration qui aboutit à 300 mais n'est jamais assigné à quoi que ce soit (même chose pour d ). Comment pensez-vous que le compilateur puisse savoir que la deuxième ligne fait en fait partie de la première expression ? Elle est valide en tant que telle.

Le présent fil fournit de plus amples informations.

Answer 2

Il semble que j'ai eu la chance d'utiliser un opérateur qui a également une version unaire. + . Le problème est que Kotlin permet un type d'expressions qui ne font en fait rien de tel :

12345

Je peux aussi avoir :

- 12345

qui n'est qu'un nombre négatif. Je peux aussi avoir un nombre positif :

+ 12345

Donc, dans ce cas :

val a = 20 +
        30

J'ai une expression, en tant que + nécessite un autre argument, qui se trouve à la ligne suivante.

Cependant, j'ai ici deux expressions

val a = 20
       + 30

La variable a aura une valeur 20 et la seconde expression ne fera rien.

Cependant, il n'existe pas de version unaire de * Cela fonctionne donc :

val a = 10 * 
        20 

y a == 200 et cela provoque une erreur de compilation :

val a = 10
        * 20 

Error:(397, 17) Kotlin: Expecting an element

L'ajout de points-virgules ne change rien, car la dernière expression n'est toujours pas valide et provoque l'erreur de compilation.

Et vous pouvez toujours utiliser des parenthèses :

val x = (10
         + 20)