Declaración "Cuando" statement vs Java "cambiar"

La coincidencia de patrones en Kotlin es agradable y el hecho de que no ejecute la próxima coincidencia de patrones es buena en el 90% de los casos de uso.

En Android, cuando la database se actualiza, utilizamos la propiedad de cambio de Java para pasar al siguiente caso si no ponemos un descanso para que el código tenga ese aspecto:

switch (oldVersion) { case 1: upgradeFromV1(); case 2: upgradeFromV2(); case 3: upgradeFromV3(); } 

Entonces, si alguien tiene una aplicación con la versión 1 de la database y se perdió la versión de la aplicación con DB v2, obtendrá todo el código de actualización necesario.

Convertido a Kotlin, tenemos un desastre como:

 when (oldVersion) { 1 -> { upgradeFromV1() upgradeFromV2() upgradeFromV3() } 2 -> { upgradeFromV2() upgradeFromV3() } 3 -> { upgradeFromV3() } } 

Aquí tenemos solo 3 versiones, imagine cuando DB alcanza la versión 19: /

De todos modos a hace cuando se actúa de la misma manera que cambiar? Intenté continuar sin suerte.

    La solución simple pero prolija es:

     if (oldVersion <= 1) upgradeFromV1() if (oldVersion <= 2) upgradeFromV2() if (oldVersion <= 3) upgradeFromV3() 

    Otra posible solución con references de function :

     fun upgradeFromV0() {} fun upgradeFromV1() {} fun upgradeFromV2() {} fun upgradeFromV3() {} val upgrades = arrayOf(::upgradeFromV0, ::upgradeFromV1, ::upgradeFromV2, ::upgradeFromV3) fun upgradeFrom(oldVersion: Int) { for (i in oldVersion..upgrades.lastIndex) { upgrades[i]() } } 

    editar: respuesta original a continuación. Esto es lo que estoy haciendo actualmente:

     fun upgrade() { fun upgradeFromV1() { /* Do stuff */ } fun upgradeFromV3() { /* Do stuff */ } tailrec fun upgradeFrom(version: Int): Unit = when (version) { LATEST_VERSION -> { Config.version = version } 1 -> { upgradeFromV1() upgradeFrom(2) } in 2..3 -> { upgradeFromV3() upgradeFrom(4) } else -> { Log("Uncaught upgrade from $version") upgradeFrom(version+1) } upgradeFrom(Config.version) } 

    Aquí hay una variación de la respuesta @CAB dio:

     fun upgrade(oldVersion: Int) { when (oldVersion) { latestVersion -> return 1 -> upgradeFromV1() 2 -> upgradeFromV2() 3 -> upgradeFromV3() } upgrade(oldVersion + 1) } 

    Qué tal esto:

     fun upgradeFromV3() {/* some code */} fun upgradeFromV2() {/* some code */ upgradeFromV3()} fun upgradeFromV1() {/* some code */ upgradeFromV2()} fun upgradeFromV0() {/* some code */ upgradeFromV1()} fun upgrade(oldVersion: Int) { when (oldVersion) { 1 -> upgradeFromV1() 2 -> upgradeFromV2() 3 -> upgradeFromV3() } } 

    Aquí hay una mezcla de las dos respuestas de bashor, con un poco de azúcar funcional:

     fun upgradeFromV0() {} fun upgradeFromV1() {} fun upgradeFromV2() {} fun upgradeFromV3() {} val upgrades = arrayOf(::upgradeFromV0, ::upgradeFromV1, ::upgradeFromV2, ::upgradeFromV3) fun upgradeFrom(oldVersion: Int) { upgrades.filterIndexed { index, kFunction0 -> oldVersion <= index } .forEach { it() } } 

    Otra variación de la respuesta de OP:

     override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { when (oldVersion) { newVersion -> return 1 -> TODO("upgrade from v1") 2 -> TODO("upgrade from v2") } onUpgrade(db, oldVersion,newVersion) } 

    Es una cita absolutamente posible de la reference oficial https://kotlinlang.org/docs/reference/control-flow.html

     If many cases should be handled in the same way, the branch conditions may be combined with a comma: when (x) { 0, 1 -> print("x == 0 or x == 1") else -> print("otherwise") } 

    Entonces, si la list de condiciones es corta, puede enumerarlas separando por coma, o usar ranges como condición en 1..10 como se indica en otras respuestas

     val orders = arrayListOf( { upgradeFromV1()}, { upgradeFromV2()}, { upgradeFromV3()} ) orders.drop(oldVersion).forEach { it() }