"Wenn" - Anweisung vs Java "switch" - Anweisung

Pattern matching in Kotlin ist schön und die Tatsache, die er nicht ausführen nächste pattern match ist gut, in 90% der Anwendungsfälle.

In Android, wenn die Datenbank aktualisiert wird, verwenden wir die Java-switch-Eigenschaft zu gehen, auf der nächsten Fall, wenn wir setzen Sie nicht ein break, um code, wie das suchen:

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

Wenn also jemand eine app mit der version 1 des DB und verpasste die app-version mit DB-v2, bekommt er alle notwendigen upgrade-code ausgeführt.

Umgewandelt Kotlin, wir bekommen ein Durcheinander:

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

Wir haben hier nur 3-version vorstellen, bei der DB erreicht version 19 :/

Sowieso macht, wenn er in der gleichen Weise als Schalter? Ich habe versucht, weiterhin ohne Glück.

Bin einfach auf youtrack.jetbrains.com/issue/KT-771 Abhilfe dann?
Ich denke, statistisch (keine Beweise, aber ich bin mir sicher, dass Kotlin-team verwendet Statistiken, um zu entscheiden), dass ein switch in Java hat fast immer eine break in jedem Fall, daher ist es ungeeignet für den Allgemeinen Fall.

InformationsquelleAutor Geob-o-matic | 2015-06-14

Einfache, aber wortreiche Lösung ist:

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

Einer anderen Lösung mit Funktion Referenzen:

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]()
    }
}

Tolle Antwort, man kann aber die Rekursion anstelle von aufrufenden Methode aus der for-Schleife

InformationsquelleAutor bashor

edit: Original-Antwort unten. Hier ist, was ich bin derzeit dabei:

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)
}

Hier ist eine variation auf die Antwort @C. A. B. gab:

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

Fügen Sie ein tailrec - Modifikator der (rekursiv genannt) - Funktion, und Sie sind golden!
bearbeitet in meine aktuelle Lösung, die ist etwas schöner, meiner Meinung nach.

InformationsquelleAutor Julian Delphiki

Wie wäre es damit:

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()
    }
}

Hinzugefügt:

Ich mag die Idee von @lukle zu definieren, die upgrade-Pfad als Liste. Dies ermöglicht es zu definieren, verschiedene upgrade-Pfade für verschiedene Anfangsphase. Zum Beispiel:

Einfachen schnellen Weg aus der freigegebenen version auf die jeweils neueste freigegebene version
Catch-up-Pfad von hot-fix-version (könnte paar in einer Zeile), das sollte nicht angewendet werden, wenn Sie von vorherigen Vollversion auf die nächste volle version

Für die, die wir brauchen, um zu wissen, welche Elemente der Liste anwenden.

fun <Vs, V> Pair<Vs, V>.apply(upgrade: () -> Unit): (V) -> V {
    return { current: V ->
        if (first == current) {
            upgrade()
            second
        } else {
            current
        }
    }
}

val upgradePath = listOf(
        (0 to 10).apply  { /* do something */ },
        (5 to 15).apply  { /* do something */ },
        (10 to 20).apply { /* do something */ },
        (15 to 20).apply { /* do something */ },
        (20 to 30).apply { /* do something */ },
        (30 to 40).apply { /* do something */ }
)

fun upgrade(oldVersion: Int) {
    var current = oldVersion
    upgradePath.forEach { current = it(current) }
}

In diesem code Vs das gleiche sein könnte, als V-oder eine Art Sammlung von V-Werte mit überschrieben equals(other: Any?): Boolean Methode.

InformationsquelleAutor C.A.B.

2

Es ist absolut möglich
Zitat aus der offiziellen Referenz : Ablaufsteuerung: wenn, wenn, für, während
```
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")
}
```
So, wenn gleiche Bedingung Liste kurz ist, dann kann man die Liste noch zu trennen von der Koma oder Bereiche benutzen, wie Bedingung in 1..10 wie bereits in anderen Antworten

Wie sieht die Hilfe mit OP ' s problem?
Vielen Dank für diese Antwort. Obwohl es nicht direkt die Frage beantworten, beantworten Sie eine Frage im Zusammenhang mit der Handhabung von verschiedenen Fällen in der gleichen Weise
Diese Antwort hat mir geholfen :), danke.

InformationsquelleAutor Yarh

Hier ist eine Mischung aus den beiden Antworten von bashor, mit ein wenig funktioneller Zucker:

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() }
}

InformationsquelleAutor lukle

0

Andere Variante von OP ' s Antwort:
```
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
    when (oldVersion) {
        newVersion -> return
        1 -> TODO("upgrade from v1 to v2")
        2 -> TODO("upgrade from v2 to v3")
    }
    oldVersion++
    onUpgrade(db, oldVersion, newVersion)
}
```
Diese Nähte wie unendliche rekursive Schleife
Meine ursprüngliche Antwort impliziert, dass oldVersion müsste erhöht werden, innerhalb der when - Anweisung. Ich habe bearbeitet die Antwort explizit zu zeigen, dass oldVersion muss erhöht werden, um zu vermeiden, dass eine unendliche Rekursion. Danke für den Hinweis.

InformationsquelleAutor arslancharyev31

Was Kotlin DSL für benutzerdefinierte Implementierung? So etwas wie dieses Ansatzes:

class SwitchTest {

    @Test
    fun switchTest() {

        switch {
            case(true) {
                println("case 1")
            }
            case(true) {
                println("case 2")
            }
            case(false) {
                println("case 3")
            }
            caseBreak(true) {
                println("case 4")
            }
            case(true) {
                println("case 5")
            }
//         default { //TODO implement
//
//         }
        }
    }
}

class Switch {
    private var wasBroken: Boolean = false

    fun case(condition: Boolean = false, block: () -> Unit) {
        if (wasBroken) return
        if (condition)
            block()
    }

    fun caseBreak(condition: Boolean = false, block: () -> Unit) {
        if (condition) {
            block()
            wasBroken = true
        }
    }
}

fun switch(block: Switch.() -> Unit): Switch {
    val switch = Switch()
    switch.block()
    return switch
}

Druckt es:
case 1 case 2 case 4
UPD: Einige refactorings und Ausgabe Beispiel.

InformationsquelleAutor Victor Yevitchenko

Können Sie einfach die for-Schleife mit wenn.

for (version in oldVersion..newVersion) when (version) {
    1 -> upgradeFromV1()
    2 -> upgradeFromV2()
    3 -> upgradeFromV3()
}

InformationsquelleAutor John

-1

val orders = arrayListOf(
            { upgradeFromV1()},
            { upgradeFromV2()},
            { upgradeFromV3()}
)

orders.drop(oldVersion).forEach { it() }

InformationsquelleAutor lukDeveloper

-3

Kotlin arbeitet mit einer anderen flow-control aufgerufen, wenn.

Ihrem code verwenden, wenn, kann auch sein.

Offensichtlich ist der code anders sein könnte, aber ich verstehe, dass deine Frage nur über die Verwendung von switch.

fun main(args: Array<String>) {
val month = 8

val monthString = when(month) {
    1 -> "Janeiro"
    2 -> "February"
    3 -> "March"
    4 -> "April"
    5 -> "May"
    6 -> "June"
    7 -> "July"
    8 -> "August"
    9 -> "September"
    12 -> "October"
    11 -> "November"
    10 -> "December"
    else -> "Invalid month"      
}

println(monthString);
}

Dies beantwortet nicht die ursprüngliche Frage.

InformationsquelleAutor Bharat Vasoya

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.