Loops (iterative statements): for and while loop; break, continue and return

📖 Theory

દરેક વસ્તુ પર કંઈક કરવું

FestConnect Mobile પાસે registrations ની યાદી તો છે; હવે એણે એમના પર કામ કરવું પડે: દરેકને છાપવું, ચૂકવણી થયેલી હોય એ ગણવી, કોઈ ચોક્કસ નામ શોધવું. એટલે કે loop ચલાવવો.

Kotlin ના loops Java પરથી પરિચિત લાગશે, પણ એક નોંધપાત્ર ફેરફાર સાથે: એમાં C જેવો for (i = 0; i < n; i++) loop છે જ નહીં. એને બદલે Kotlin નું for હંમેશા કોઈ iterable વસ્તુ પર ફરે છે, એટલે કે range કે collection પર, જે વધુ સ્પષ્ટ વંચાય છે. આ ટૂંકો પાઠ Kotlin ના for અને while loops તથા break, continue અને return જેવા કાબૂના keywords આવરી લે છે, અને OOP વાળા એકમ પહેલાં ભાષાના પાયા પૂરા કરે છે.

📖 Theory

for એ ranges અને collections પર ફરે છે

Kotlin નું for loop હંમેશા કોઈ iterable વસ્તુ પર ચાલે છે:

• range: for (i in 1..5) { ... } (1 થી 5)
• collection: for (event in events) { ... } (સીધી દરેક વસ્તુ)
• index સાથે: for (i in events.indices) અથવા for ((i, e) in events.withIndex()) (index અને વસ્તુ બંને)

for (i = 0; i < n; i++) જેવું કંઈ છે જ નહીં; Kotlin એને બદલે ranges વાપરે છે (for (i in 0 until events.size)). રોજિંદો વપરાશ તો for (event in events) વાળો છે: એ તમને દરેક ઘટક સીધું સોંપે છે, અને index નો હિસાબ રાખવો પડતો નથી. while અને do-while બરાબર Java ની જેમ જ ચાલે છે: શરત સાચી હોય ત્યાં સુધી loop ચાલે.

⌨️ Practical

યાદી પર for, અને સાથે break તથા continue

fun main() {
    val events = listOf("Garba", "Coding", "Robo", "Quiz")

    // collection પર for: સીધી દરેક વસ્તુ
    for (event in events) {
        if (event == "Robo") continue   // Robo છોડી દો
        if (event == "Quiz") break      // Quiz પર અટકી જાઓ
        println(event)                  // Garba, Coding
    }

    // index સાથે range પર for
    for (i in 1..3) {
        println("Pass $i")              // Pass 1, Pass 2, Pass 3
    }

    // while: શરત પર ચાલતો, Java ની જેમ જ
    var seats = 3
    while (seats > 0) {
        seats--
    }
    println(seats)                     // 0
}

📖 Theory

break, continue, return અને labels

કાબૂનાં ત્રણ keywords loops ને દોરે છે:

• break: loop માંથી સાવ બહાર નીકળી જવું
• continue: પછીના આંટા પર કૂદી જવું
• return: આખા FUNCTION માંથી બહાર નીકળી જવું (ફક્ત loop માંથી નહીં)

ઉપરના listing માં continue Robo ને છોડી દે છે અને break Quiz પર અટકાવી દે છે, એટલે ફક્ત Garba અને Coding જ છપાય છે.

એકબીજામાં ગૂંથાયેલા loops માં સાદાં break અને continue ફક્ત સૌથી અંદરના loop ને જ અસર કરે છે. બહારના loop ને તાકવા માટે label વાપરો: loop પહેલાં outer@ લખો, અને પછી break@outer કે continue@outer એ label વાળા loop પર કૂદે છે. ગૂંથાયેલા loop માંથી નીકળવાની આ એ જ રીત છે જે તમે Dart (BCA405-02) અને Java (BCA403) માં જોઈ હતી, ફક્ત અહીં Kotlin ની @ વાળી label syntax છે.

🧩 Quiz

Loop ચલાવવા માટે Java માં જે છે તે Kotlin માં શું નથી?

1. while loop
2. C જેવો for loop: for (i = 0; i < n; i++); Kotlin એને બદલે ranges (for i in 0 until n) કે collection પરનું iteration વાપરે છે
3. break keyword
4. loop ચલાવવાની ક્ષમતા જ

💭 Think first

C જેવો for loop કેમ કાઢી નાખ્યો?

Java નું for (i = 0; i < n; i++) પરિચિત પણ છે અને લવચીક પણ. તો Kotlin એ ranges અને collection પરના iteration ની તરફેણમાં એને કેમ કાઢી નાખ્યું? વિચારીને પછી tap કરો.

⚠️ Watch out

Loop ના ફાંદા

C જેવો for શોધવો: એને બદલે ranges (for i in 0 until n) કે for (item in list) વાપરો.

Loops માં .. સામે until: 1..n માં n આવે છે; 0 until n એ n-1 પર અટકે છે (0 થી શરૂ થતા indices માટે યોગ્ય).

ગૂંથાયેલા loops માં break અને continue: એ ફક્ત અંદરના loop ને અસર કરે છે; બહારના માટે label વાપરો (break@outer).

return આખા function માંથી બહાર કાઢે છે: ફક્ત loop માંથી નહીં; loop છોડવા break વાપરો.

અનંત while: ખાતરી કરો કે શરત આખરે ખોટી પડે (અંદર ચલ બદલો).

📖 Theory

Kotlin ના પાયા પૂરા; હવે OOP

હવે તમારી પાસે Kotlin ના પાયા છે: ચલ અને null safety, when તથા ranges સાથે conditionals, collections, અને loops, એટલે કે ખરું logic લખવા જેટલું. એકમ 2 FestConnect Mobile ની રચના Kotlin ની OBJECT ORIENTED સુવિધાઓથી બાંધે છે: classes, constructors, named parameters, અને પોતાના વળાંક સાથેનું inheritance (classes મૂળભૂત રીતે final હોય છે; વારસો લેવો હોય તો એમને open ચિહ્નિત કરવાં પડે). તમારું Java નું OOP જ્ઞાન સીધું કામ લાગશે, ફક્ત Kotlin ની ટૂંકી syntax સાથે. પાયામાંથી હવે રચના તરફ.

✅ Summary

Key takeaways

• Kotlin નું for હંમેશા કોઈ iterable વસ્તુ પર ફરે છે: range (for i in 1..5), collection (for item in list), કે indices.
• C જેવો for (i=0; i<n; i++) છે જ નહીં; એને બદલે ranges વાપરો (for i in 0 until n).
• while અને do-while Java ની જેમ જ ચાલે છે (શરત પર આધારિત).
• break loop માંથી બહાર કાઢે છે, continue પછીના આંટા પર કૂદે છે, અને return આખા function માંથી બહાર કાઢે છે.
• ગૂંથાયેલા loops માટે labels (outer@ ... break@outer) ચોક્કસ બહારના loop ને તાકે છે.
• for (item in collection) એ રોજિંદું સ્વરૂપ છે, જે index વગર જ તમને દરેક ઘટક સોંપે છે.
• યાદ રાખવાની કડી: Kotlin ranges અને collections પર loop ચલાવે છે, હાથે ગણતરી રાખતો for નથી.