मुख्य कंटेंट तक स्किप करें
Wave
GitHub

लूप्स

परिचय​

Wave भाषा में उन स्थितियों को संभालने के लिए लूप्स प्रदान किए जाते हैं जहां एक ही कोड को कई बार चलाया जाना चाहिए। लूप्स का उपयोग तब किया जाता है जब कोड को तब तक चलाना होता है जब तक एक विशेष शर्त संतुष्ट नहीं होती है या एक विशिष्ट संख्या में दोहराया जाने तक।

इसके माध्यम से, आपको एक ही लॉजिक को बार-बार लिखने की आवश्यकता नहीं होती है, और आप उसको संक्षिप्त और स्पष्ट कोड द्वारा दोहराए गए कार्य के रूप में व्यक्त कर सकते हैं। Wave स्थिति पर आधारित पुनरावृत्ति और संख्या पर आधारित पुनरावृत्ति दोनों का समर्थन करता है, साथ ही साथ पुनरावृत्ति के दौरान निष्पादन प्रवाह को नियंत्रित करने के लिए कीवर्ड भी प्रदान करता है।

इस अनुभाग में while और for लूप के साथ-साथ break और continue जैसे कीवर्ड का उपयोग करने के तरीके का वर्णन है, जो पुनरावृत्ति प्रवाह को नियंत्रित करते हैं।

while लूप​

while लूप को तब तक चलाता है जब तक कि दी गई शर्त को 'सत्य' (true) मान न मिल जाए। शर्त के 'झूठी' (false) होते ही पुनरावृत्ति तुरंत समाप्त हो जाती है।

यह तरीके तब उपयुक्त होते हैं जब पुनरावृत्ति की संख्या स्पष्ट नहीं होती है, और इसे तब तक दोहराना होता है जब तक कि कोई विशिष्ट शर्त संतुष्ट न हो जाए।

मूल संरचना​

Wave में while लूप की मूल संरचना इस प्रकार है।

while (condition) {
    // दोहराने के लिए कोड
}

शर्त को अवश्य ही {} प्रकार में मूल्यांकित किया जाना चाहिए, और कोड ब्लॉक में, जो {} में घिरा हुआ है, एक या अधिक निर्देश होते हैं।

उदाहरण: 0 से 4 तक प्रिंट करें​

var i :i32 = 0;

while (i < 5) {
    println("मैं {} हूं.", i);
    i = i + 1;
}

इस उदाहरण में, जब तक परिवर्तनीय i 5 से छोटा होता है, पुनरावृत्ति की जाती है। हर पुनरावृत्ति में वर्तमान मान को प्रिंट किया जाता है, और i के मान को एक-एक करके बढ़ाकर शर्त को अंततः गलत बना दिया जाता है।

for लूप​

for लूप्स उन मामलों में उपयुक्त होते हैं जहां पुनरावृत्ति की संख्या स्पष्ट होती है। प्रारंभिक मान, स्थिति, और वृद्धि को एक ही बार में परिभाषित करके पुनरावृत्ति के प्रवाह को स्पष्ट रूप से व्यक्त किया जा सकता है।

चूंकि पुनरावृत्ति नियंत्रण में आवश्यक तत्व एक स्थान पर होते हैं, इसलिए पुनरावृत्ति संरचना को एक बार में समझना आसान होता है।

मूल संरचना​

for (init; condition; step) {
    // दोहराने के लिए कोड
}

Wave में for लूप की प्रारंभिक अवस्था कई प्रकारों का समर्थन करती है।

  • अप्रत्यक्ष var प्रकार की प्रारंभिक अवस्था
  • var / let mut / const घोषणा प्रारंभिक अवस्था
  • साधारण अभिव्यक्ति प्रारंभिक अवस्था (मौजूदा परिवर्तनीय पुनः उपयोग)

उदाहरण 1: अप्रत्यक्ष प्रकार की प्रारंभिक अवस्था​

for (i :i32 = 1; i <= 5; i += 1) {
    println("i = {}", i);
}

उदाहरण 2: var / let mut प्रारंभिक अवस्था​

for (var i: i32 = 0; i < 3; i += 1) {
    println("var i = {}", i);
}

for (let mut j: i32 = 0; j < 3; j += 1) {
    println("let mut j = {}", j);
}

उदाहरण 3: अभिव्यक्ति आधारित प्रारंभिक अवस्था (मौजूदा परिवर्तनीय पुनः उपयोग)​

var i: i32 = 99;

for (i = 3; i <= 5; i += 1) {
    println("i = {}", i);
}

println("after loop: {}", i); // 6

डिक्लेरेटिव प्रारंभिक अवस्था (var, let mut, i :i32 = ...) लूप स्कोप परिवर्तनीय के रूप में कार्य करती है, और अभिव्यक्ति आधारित प्रारंभिक अवस्था (i = ...) बाहरी परिवर्तनीय को अपडेट करती है।

घोंसले बनाना लूप्स​

लूप्स के अंदर अन्य लूप्स लिखा जा सकता है, इसे घोंसला बनाना लूप्स कहा जाता है। घोंसले बनाना लूप्स का उपयोग तब होता है जब दो-आयामी डेटा संरचनाओं को पार करना या कई शर्तों के संयोजन का प्रबंधन करना होता है।

उदाहरण: दोहरा while लूप​

var i :i32 = 0;

while (i < 3) {
    var j :i32 = 0;

    while (j < 2) {
        println("i={}, j={}", i, j);
        j = j + 1;
    }

    i = i + 1;
}

इस उदाहरण में, बाहरी i लूप के हर बार चलने के बाद, आंतरिक j सभी लूप्स चलते हैं। इसके माध्यम से, (i, j) प्रकार के संयोजनों को क्रमशः संसाधित किया जा सकता है।

break लूप​

break लूप को तुरंत समाप्त कर देता है और प्रवाह को उस लूप के बाहर ले जाता है। यह तब उपयोग किया जाता है जब पुनरावृत्ति के दौरान अब और पुनरावृत्ति करने की कोई आवश्यकता नहीं होती है।

उदाहरण: एक विशिष्ट मान पर लूप का अंत​

var i :i32 = 0;

while (true) {
    if (i == 5) {
        break;
    }

    println(i);
    i = i + 1;
}

इस उदाहरण में, जब अनंत लूप में i का मान 5 हो जाता है, तब break निष्पादित होता है और लूप समाप्त हो जाता है। break कथन तब उपयोगी होता है जब आप पुनरावृत्ति की शर्तों से स्वतंत्र होकर उसे नियंत्रित करना चाहते हैं।

continue लूप​

continue कथन वर्तमान पुनरावृत्ति में शेष कोड को छोड़ देता है और अगली पुनरावृत्ति को तुरंत शुरू करता है। यह तब इस्तेमाल होता है जब आप केवल एक विशिष्ट शर्त पर कुछ लॉजिक को छोड़ना चाहते हैं।

उदाहरण: केवल सम संख्याएँ प्रिंट करें​

for (var i: i32 = 0; i <= 10; i = i + 1) {
    if (i % 2 == 1) {
        continue;
    }

    println(i);
}

इस कोड में, जब i का मान विषम होता है, तब continue निष्पादित होता है और यह प्रिंटिंग भाग को छोड़ देता है। परिणामस्वरूप, केवल सम मान मुद्रित होते हैं।

सारांश​

Wave की लूपिंग तब डिजाइन की गई है कि वह स्थिति आधारित और संख्या आधारित पुनरावृत्तियों को स्वाभाविक रूप से व्यक्त कर सके। while कथन स्थिति-केंद्रित पुनरावृत्तियों के लिए उपयुक्त है, जबकि for कथन तब उपयोगी होते हैं जब पुनरावृत्ति की संख्या और प्रवाह स्पष्ट होते हैं।

break और continue का एक साथ उपयोग करें, तो आप पुनरावृत्ति के दौरान निष्पादन प्रवाह को बारीकी से नियंत्रित कर सकते हैं, जिससे अधिक जटिल और लचीली पुनरावृत्ति लॉजिक निर्मित की जा सकती है।