Conditional statements: if and when; difference between if and when; ranges, types, values of function calls

📖 Theory

કિંમત પાછી આપતા નિર્ણયો

FestConnect Mobile એ events ને વર્ગીકૃત કરવા પડે: 0 બેઠકવાળો event એટલે 'Sold out', 1 થી 50 એટલે 'Filling up', એથી વધુ એટલે 'Available'. Java (BCA403) માં તમે if-else ની સાંકળ લખો, અથવા break વાળું switch લખો.

Kotlin આ કામ વધુ સફાઈથી કરે છે, અને એમાં બે એવા વળાંક છે જે Java programmers ને નવાઈ પમાડે છે: એનાં if અને when એ EXPRESSIONS છે જે કિંમત પાછી આપે છે, અને એનું when (switch ની અવેજી) ફક્ત એકલી કિંમતો જ નહીં, RANGES અને TYPES પણ match કરી શકે છે. આ પાઠ Kotlin ના conditionals અને ranges આવરી લે છે, જ્યાં ભાષાની ટૂંકાણની ખૂબી દેખાય છે.

📖 Theory

Expression તરીકે if

Kotlin નું if statement તરીકે પણ કામ કરે છે (Java ની જેમ) અને કિંમત પાછી આપતા expression તરીકે પણ:

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

આખું if એક કિંમતમાં પરિણમે છે અને એ કિંમત સોંપાય છે. આ Java ના ternary operator (a > b ? a : b) ની જગ્યા લે છે: Kotlin માં ternary છે જ નહીં, કારણ કે if એ કામ પહેલેથી જ, અને વધુ સહેલાઈથી વંચાય એ રીતે, કરી આપે છે. જે શાખા ચાલે તે કિંમત પૂરી પાડે છે.

Expression હોવાનો આ સ્વભાવ Kotlin માં વારંવાર દેખાય છે: Java માં જે માત્ર statements હતાં તે અહીં ઘણી વાર કિંમત પાછી આપે છે, જેથી તમે val result = if (...) ... else ... સફાઈથી લખી શકો.

⌨️ Practical

Ranges સાથે when, અને expression તરીકે if

fun classify(seats: Int): String {
    // when: તાકાતવાળું switch, અને expression પણ (કિંમત પાછી આપે છે)
    return when (seats) {
        0 -> "Sold out"              // એક કિંમત
        in 1..50 -> "Filling up"     // RANGE (1 થી 50, બંને સહિત)
        in 51..200 -> "Available"
        else -> "Plenty of seats"    // else (default જેવું)
    }
}

fun main() {
    println(classify(0))     // Sold out
    println(classify(30))    // Filling up   (30 એ 1..50 માં છે)
    println(classify(500))   // Plenty of seats

    // if ને expression તરીકે (Java ના ternary ની જગ્યાએ):
    val a = 7; val b = 4
    val max = if (a > b) a else b
    println(max)             // 7
}

📖 Theory

when અને ranges

when એ Kotlin નું switch છે, પણ ઘણું વધારે સક્ષમ, અને એને break ની જરૂર જ પડતી નથી:

• એક કિંમત match કરો: 0 -> ...
• અનેક કિંમતો: 1, 2 -> ...
• RANGE: in 1..50 -> ...
• type: is String -> ...
• else (default જેવું)

અને when એ EXPRESSION છે, એટલે એ સીધી કિંમત પાછી આપી શકે છે (ઉપરના listing માં when ને જ return કરેલું છે).

Ranges .. વાપરે છે: 1..10 એટલે 1 થી 10, બંને સહિત. એ when માં (in 1..50), loops માં (for (i in 1..5)) અને શરતોમાં (if (x in 1..10)) દેખાય છે. એના પ્રકારો: until (છેડો બહાર, 1 until 10 એટલે 1 થી 9), downTo (ઊતરતો ક્રમ), step (કૂદકો). Ranges સંખ્યાની શરતોને લગભગ બોલચાલ જેવી વાંચવા યોગ્ય બનાવે છે: if (seats in 1..50).

🧩 Quiz

Kotlin નું when Java ના switch થી કઈ રીતે જુદું પડે છે?

1. when ને switch ની જેમ દરેક શાખા પછી break જોઈએ છે
2. when ને break ની જરૂર જ પડતી નથી, એ ranges (in 1..50) અને types (is String) match કરી શકે છે, અને એ કિંમત પાછી આપતું EXPRESSION છે
3. when ફક્ત એકલી integer કિંમતો જ match કરી શકે છે
4. when અને switch સાવ એકસરખાં છે

💭 Think first

if કે when: FestConnect માટે કયું?

FestConnect Mobile ને (a) બે બેઠક-સંખ્યાઓમાંથી મોટી પસંદ કરવી છે, અને (b) બેઠકના range પ્રમાણે event ને પાંચ વર્ગોમાંથી એકમાં મૂકવો છે. દરેક માટે કયું conditional બંધ બેસે, અને શા માટે? વિચારીને પછી tap કરો.

⚠️ Watch out

Conditional ના ફાંદા

when માં break ની અપેક્ષા: એવું કંઈ છે જ નહીં; દરેક શાખા એકલી ચાલે છે (fall-through થતું નથી).

Expression તરીકે when ને else જોઈએ: કિંમત પાછી આપતું when સંપૂર્ણ હોવું જોઈએ; else ઉમેરો (સિવાય કે બધા કિસ્સા આવરી લેવાયા હોય, દા.ત. enum).

.. સામે until: 1..10 માં 10 આવે છે; 1 until 10 નવ પર અટકે છે; સીમા પ્રમાણે સાચું પસંદ કરો.

Ternary શોધવું: Kotlin માં એ છે જ નહીં; if ને expression તરીકે વાપરો.

Ranges મુખ્યત્વે સંખ્યા જેવા પ્રકારો માટે: .. સરખાવી શકાય એવા પ્રકારો (Int, Char) માટે ચાલે છે; જ્યાં ક્રમનો અર્થ હોય ત્યાં જ વાપરો.

📖 Theory

નિર્ણયો પૂરા; હવે collections

FestConnect Mobile હવે if, when અને ranges વડે નિર્ણય લઈ શકે છે અને વર્ગીકરણ કરી શકે છે. ખરી apps માં data ની યાદીઓ હોય છે, જેમ કે events ની યાદી, નોંધાયેલા લોકોની યાદી. પછીનો પાઠ Kotlin નાં arrays અને lists આવરી લે છે, એટલે કે એમને કઈ રીતે બનાવવાં, વાપરવાં અને બદલવાં, જેમાં read-only સામે mutable list નો મહત્ત્વનો ભેદ પણ આવે છે, જે val સામે var ના ભેદનો પડઘો પાડે છે. પછી loops Kotlin ના પાયા પૂરા કરે છે, અને OOP વાળો એકમ app ના classes બાંધે છે.

✅ Summary

Key takeaways

• Kotlin નું if એ statement પણ છે અને કિંમત પાછી આપતું EXPRESSION પણ: val max = if (a > b) a else b (Java ના ternary ની જગ્યા લે છે).
• when એ Kotlin માં switch ની અવેજી છે: break ની જરૂર નથી, અને એ પણ expression છે.
• when એકલી કિંમતો, અનેક કિંમતો (1, 2 ->), ranges (in 1..50 ->) અને types (is String ->) match કરે છે, અને else default તરીકે કામ કરે છે.
• Ranges .. વાપરે છે: 1..10 માં બંને છેડા આવે છે; until માં છેડો બહાર રહે છે (1 until 10 એટલે 1 થી 9); downTo ઊતરતો ક્રમ ગણે છે; step કૂદકો મારે છે.
• Ranges when માં, loops માં (for i in 1..5) અને શરતોમાં (if (x in 1..10)) દેખાય છે.
• બે બાજુના કે boolean નિર્ણયો માટે if વાપરો, અને એક કિંમતને ઘણા કિસ્સાઓ સામે match કરવા માટે when (ખાસ કરીને ranges કે types સાથે).
• યાદ રાખવાની કડી: if અને when કિંમત પાછી આપે છે; when ને break જોઈતું નથી અને એ ranges તથા types match કરે છે.