Kotlin Academy · पाठ

break, continue और लेबल वाले रिटर्न

break/continue से लूप के प्रवाह को नियंत्रित करें और लेबल की सहायता से नेस्टेड लूप से बाहर निकलें।

पाठ 4, कुल 4 में से13 चरण

break, continue और लेबल वाले रिटर्न, CoddyKit पर Kotlin Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Kotlin Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

लूप का प्रवाह नियंत्रण

Kotlin break (लूप से बाहर निकलना), continue (अगली पुनरावृत्ति पर जाना) और नेस्टेड लूप से बाहर निकलने के लिए labels का समर्थन करता है।

break की मूल बातें

break सबसे अंदर वाले संलग्न लूप से तुरंत बाहर निकलता है।

fun main() {
    for (i in 1..10) {
        if (i == 5) break
        print("$i ")
    }
    println() // 1 2 3 4
}

continue की मूल बातें

continue वर्तमान पुनरावृत्ति का शेष भाग छोड़कर अगली पुनरावृत्ति पर चला जाता है।

fun main() {
    for (i in 1..10) {
        if (i % 2 == 0) continue
        print("$i ")
    }
    println() // 1 3 5 7 9
}

लेबल वाले लूप

लूप को label@ से टैग करें और नेस्टेड लूप के अंदर से बाहरी लूप को नियंत्रित करने के लिए break@label या continue@label का संदर्भ लें।

fun main() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (i == 2 && j == 2) break@outer
            println("$i,$j")
        }
    }
}

लेबल के साथ continue

बाहरी लूप की अगली पुनरावृत्ति पर जाने के लिए continue@outer का उपयोग करें।

fun main() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (j == 2) continue@outer
            println("i=$i j=$j")
        }
    }
}

return@lambda

forEach और अन्य इनलाइन फ़ंक्शन के अंदर साधारण return संलग्न फ़ंक्शन से बाहर निकलता है। केवल लैम्ब्डा से बाहर निकलने के लिए return@forEach का उपयोग करें।

fun main() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach
        println(it)
    }
    println("Done")
}

लैम्ब्डा में नॉन-लोकल return

यदि लैम्ब्डा इनलाइन है (जैसे forEach), तो साधारण return पूरे संलग्न फ़ंक्शन से बाहर निकलता है — जो कभी-कभी आश्चर्यजनक हो सकता है।

fun process() {
    listOf(1, 2, 3).forEach {
        if (it == 2) return // exits process()
        println(it)
    }
    println("never printed")
}
fun main() { process() }

लैम्ब्डा पर कस्टम लेबल

अधिक स्पष्ट return लक्ष्य के लिए आप लैम्ब्डा को name@ से स्पष्ट रूप से लेबल कर सकते हैं।

fun main() {
    listOf(1, 2, 3, 4).forEach loop@{
        if (it == 3) return@loop
        println(it)
    }
}

while में break

break और continue, while और do-while दोनों में एक ही तरह काम करते हैं।

fun main() {
    var i = 0
    while (true) {
        if (i >= 3) break
        println("i = $i")
        i++
    }
}

लेबल और continue को मिलाना

लेबल और continue फ़्लैग चरों के बिना नेस्टेड एल्गोरिदम की पूरी पुनरावृत्तियों को छोड़ने देते हैं।

fun main() {
    val grid = listOf(listOf(1,2,0), listOf(3,4,5), listOf(0,6,7))
    rows@ for (row in grid) {
        for (cell in row) {
            if (cell == 0) continue@rows
            print("$cell ")
        }
        println()
    }
}

लेबल का उपयोग कब न करें

लेबल जटिलता बढ़ाते हैं। यदि आप अक्सर उनका उपयोग करने लगें, तो आंतरिक लूप को साधारण return वाले फ़ंक्शन में निकालने पर विचार करें।

fun firstMatch(grid: List<List<Int>>, target: Int): Pair<Int,Int>? {
    for (r in grid.indices) for (c in grid[r].indices) {
        if (grid[r][c] == target) return r to c
    }
    return null
}
fun main() {
    val g = listOf(listOf(1,2),listOf(3,4))
    println(firstMatch(g, 3))
}

त्वरित जाँच

Kotlin में आंतरिक लूप के अंदर से बाहरी लूप से बाहर कैसे निकलते हैं?

पुनरावलोकन

break सबसे अंदर वाले लूप से बाहर निकलता है; continue अगली पुनरावृत्ति पर चला जाता है। नेस्टेड नियंत्रण के लिए label@ + break@label/continue@label का उपयोग करें। लैम्ब्डा में नॉन-लोकल निकास से बचने के लिए return के बजाय return@forEach को प्राथमिकता दें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Kotlin सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
51
पाठ
203

अक्सर पूछे जाने वाले प्रश्न

क्या “break, continue और लेबल वाले रिटर्न” पाठ निःशुल्क है?

हाँ — Kotlin Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “break, continue और लेबल वाले रिटर्न” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“break, continue और लेबल वाले रिटर्न” में मैं क्या सीखूँगा?

break/continue से लूप के प्रवाह को नियंत्रित करें और लेबल की सहायता से नेस्टेड लूप से बाहर निकलें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Kotlin Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Kotlin Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Kotlin Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“break, continue और लेबल वाले रिटर्न” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Kotlin Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Kotlin Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. रेंज और संग्रह पर for लूप
  2. while और do-while: किसका उपयोग कब करें
  3. forEach, repeat और forEachIndexed
  4. break, continue और लेबल वाले रिटर्न
← Kotlin Academy पर वापस जाएँ