"कब" कथन बनाम जावा "स्विच" कथन

Question

कोटलिन में पैटर्न मिलान अच्छा है और तथ्य यह है कि यह अगले पैटर्न मैच को निष्पादित नहीं करता है 90% उपयोग मामलों में अच्छा है।

एंड्रॉयड में, जब डेटाबेस अद्यतन किया जाता है, हम जावा प्रॉपर्टी को बदलना कोड कि तरह लग रही है करने के लिए अगले मामले पर जाने के लिए अगर हम एक ब्रेक डाल नहीं का उपयोग करें:

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

किसी के साथ किसी ऐप है तो अगर डीबी के संस्करण 1 और डीबी v2 के साथ ऐप संस्करण को याद किया, उसे निष्पादित सभी आवश्यक अपग्रेड कोड मिलेगा।

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

यहाँ हम केवल 3 संस्करण है, कल्पना जब डीबी संस्करण 19 तक पहुँच जाता है: जब से एक ही तरह से काम कर रहा बनाता करने के लिए वैसे भी/

Kotlin में बदल दिया है, हम एक गड़बड़ की तरह मिलता है स्विच? मैंने भाग्य के बिना जारी रखने की कोशिश की।

Answer 1

सरल लेकिन अधिक शब्दों वाले समाधान है:

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

एक अन्य संभावित समाधान function references साथ:

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

Answer 2

कैसे इस बारे में:

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

Answer 3

संपादित करें: नीचे मूल प्रतिक्रिया। यहाँ मैं वर्तमान में क्या कर रहा है:

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

---

यहाँ जवाब @ C.A.B पर एक परिवर्तन हो। दिया:

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

Answer 4

यहाँ, bashor से दो जवाब का एक मिश्रण है कार्यात्मक चीनी का एक छोटा सा के साथ: offisial संदर्भ से

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

Answer 5

यह absolutly संभव है बोली 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") 
} 

तो यदि समान स्थिति सूची कम है, तो आप उन्हें कोमा द्वारा अलग करने की सूची दे सकते हैं, या अन्य उत्तरों में बताए गए अनुसार 1.10 की स्थिति जैसे श्रेणियों का उपयोग कर सकते हैं

Answer 6

ओपी के जवाब का एक और भिन्नता:

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

Answer 7

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

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