ऑपरेटर सिंटैक्स:

के लिएविरोध करना= शुरू टीहेअंत[कदमकदम]

ब्लॉक_ऑपरेटर

अगलाविरोध करना

यहाँ यह दर्शाया गया है:

के लिए – के लिए (आवश्यक कीवर्डवीबी);

को – को (आवश्यक कीवर्डवीबी);

ब्लॉक_ऑपरेटर- एक या अधिक ऑपरेटरों को बुलाया गया चक्र का शरीर;

विरोध करना -एक पूर्णांक चर जो निष्पादित लूपों की संख्या की गणना करता है;

आदि अंत -प्रारंभिक और अंतिम काउंटर मान;

कदम – चरण(कीवर्डवीबी);

कदम -काउंटर परिवर्तन कदम; नकारात्मक हो सकता है; पैरामीटर वैकल्पिक है, क्योंकि यदि चरण 1 है, तो आप कदम उठा सकते हैं कदमनिचला;

अगला - अगला (आवश्यक कीवर्ड वीबी, लूप ऑपरेटर प्रविष्टि का अंत)।

काउंटर वैल्यू (अंत शुरू)वहाँ हो सकता है पूर्णांक या वास्तविक प्रकार के संख्यात्मक स्थिरांक या चर, ऋणात्मक या धनात्मक संख्या हो सकते हैं। लूप की बॉडी को कम से कम एक बार निष्पादित करने के लिए, यह अवश्य होना चाहिए शुरुआत ≤ अंत,अगर कदम> 0, और शुरुआत ≥ अंत,अगर कदम< 0. जैसे ही यह पता चला विरोध करना>अंत (अगर शुरू< Конец), लूप निष्पादन समाप्त होता है। अगर प्रारंभ =अंत,लूप को एक बार निष्पादित किया जाएगा;

उदाहरण 9.1 .कार्य मूल्यांकनवाई = 2 – 1.5 सिंक्सजब X श्रेणी में 0.2 के चरणों में बदलता है।

Y की गणना करने और तर्क X और फ़ंक्शन Y को आउटपुट करने के लिए एक प्रोग्राम का एक टुकड़ा:

एक्स = 0 से 2.4 के लिए चरण 0.2

Y = 2 – 1.5*Sin(X)

यह समझने के लिए कि यह लूप कैसे काम करता है, यहां इसी तरह के लूप का उपयोग करके बनाया गया एक प्रोग्राम है ऑपरेटरजाओ, टैग, ऑपरेटरअगर… तब.

एम1: एक्स = एक्स + 0.2

यदि एक्स<= 2.4 Then

Y = 2 – 1.5*Sin(X)

आइए देखें कि यह प्रोग्राम कैसे काम करता है। पहली गणना Y गैर-मानक है, मानो यह चक्र से बाहर हो गई हो। चक्र M1 लेबल पर नियंत्रण GoToM1 के पहले हस्तांतरण के बाद शुरू होता है। M1 लेबल वाली पंक्ति में, तर्क यदि यह अधिक नहीं है, तो Y की गणना इस नए X के साथ दोहराई जाती है। फिर GoToM1 ऑपरेटर को फिर से निष्पादित किया जाता है - नियंत्रण को M1 लेबल वाली लाइन पर स्थानांतरित किया जाता है। जैसे ही X 2.4 से अधिक हो जाएगा, Y की गणना के ये पुनरावृत्तियाँ (चक्र) समाप्त हो जाएँगी।

अब आइए प्रोग्राम की तुलना इफ से फॉर...नेक्स्ट लूप से करें।

एक्स = 0 से 2.4 के लिए चरण 0.2

दो पंक्तियों को प्रतिस्थापित करता है

एम1: एक्स = एक्स + 0.2

यदि एक्स<= 2.4 Then

यह कोड की अंतिम दो पंक्तियाँ हैं जिन्हें फ़ॉर लूप में निष्पादित किया जाता है, लेकिन हम इसे नहीं देखते हैं। हमने उन्हें लाइन cFor के साथ एनकोड किया है... कोड की GoTo M1 लाइन को Next X (शाब्दिक रूप से: अगला X) शब्द के साथ एन्कोड किया गया है। इसके परिणामस्वरूप एक कॉम्पैक्ट डिज़ाइन प्राप्त होता है।

फॉर...नेक्स्ट लूप का उपयोग करते समय, आपको यह सीखना होगा कि विभिन्न समस्याओं को हल करने के लिए लूप काउंटर का उपयोग कैसे करें। किसी समस्या को हल करने के लिए काउंटर का उपयोग कैसे करें, यह जानने के लिए आपको इसकी आवश्यकता है समस्या के सूत्रीकरण का विश्लेषण करें, समस्या के कुछ मापदंडों में परिवर्तन के पैटर्न खोजें।

उदाहरण 9.2 . किसी शृंखला के तत्वों का योग ज्ञात करना: .

कार्यक्रम खंड:

एस = 0 ' एस - श्रृंखला का योग

i = 1 से 16' के लिए काउंटर i भिन्न का हर है

S = S + 1/i' राशि का संचय

“S=” प्रिंट करें; S ' राशि S को फॉर्म में आउटपुट करता है

काउंटर i के प्रत्येक मान के लिए, अभिव्यक्ति 1/i क्रमिक रूप से 1 से शुरू होकर श्रृंखला के तत्वों का निर्माण करती है।

उदाहरण 9.3 . तत्वों की एक श्रृंखला के योग की गणना
.

कार्यक्रम खंड:

एस = 0 ' एस - श्रृंखला का योग

i = 1 से 18' के लिए काउंटर i - अंश

S = S + i/(i + 1) ' हर, अंश से 1 बड़ा है

“S=” प्रिंट करें; S ' राशि S को फॉर्म में आउटपुट करता है

उदाहरण 9.4 . योग की गणना: 5 + 8 + 11 +… + 32 + 35

कार्यक्रम खंड:

एस = 0 ' एस - श्रृंखला का योग

i = 5 से 35 चरण 3 के लिए हमें अंकगणित प्राप्त होता है _

हर 3 के साथ प्रगति

“S=” प्रिंट करें; एस

उदाहरण 9.5. किसी दिए गए x के लिए योग की गणना:

समस्या के विश्लेषण से पता चलता है कि X की डिग्री 1 से 10 तक भिन्न होती है। इस मामले में, X के गुणांक में अंश, डिग्री से 1 और हर 2 से अधिक है। हम डिग्री का मान का उपयोग करके बनाएंगे काउंटर मैं. फिर आप इस तरह एक प्रोग्राम बना सकते हैं (टुकड़ा):

एस = 1' एस - श्रृंखला का योग

i = 1 से 10' के लिए, काउंटर i की तरह, X पर डिग्री बदल जाती है

एस = एस + (-1)^आई*(आई + 1)*x^आई / (आई + 2)

“S=” प्रिंट करें; एस

साइकिलके लिए… अगलाके लिए इस्तेमाल होता हैइनपुट आउटपुट औरसरणी प्रसंस्करण .

उदाहरण 9.6. सरणी तत्वों बी के मूल्यों का इनपुट और आउटपुटएन).

कार्यक्रम खंड:

' हम वेरिएबल एन को मान निर्दिष्ट करना छोड़ देते हैं, _

फॉर्म में txtN टेक्स्ट फ़ील्ड में दर्ज किया गया:

बी(आई) = इनपुटबॉक्स("आइटम बी दर्ज करें(" और आई और ")", _

"इनपुट सरणी बी(" एवं एन एवं ")")

प्रिंट करें ""; बी(आई);

समारोह इनपुटबॉक्स() बंद करें बटन, एक निर्दिष्ट संदेश, एक इनपुट फ़ील्ड, बटन के साथ एक संवाद बॉक्स प्रदर्शित करता है ठीक है,रद्द करना,किसी दिए गए हेडर के साथ (या इसके बिना)। यदि संख्या 12 दर्ज की गई है - सरणी एन का आकार, तो हमारे उदाहरण में, जब यह पहली बार दिखाई देगी, तो यह विंडो इस तरह दिखेगी:

जैसा कि हम देख सकते हैं, संदेश तत्व बी(1) दर्ज करेंआपको टेक्स्ट बॉक्स में पहले तत्व का मान दर्ज करने के लिए संकेत देता है। यह विंडो 12 बार दिखाई देगी क्योंकि सरणी में 12 तत्व हैं। यह प्रपत्र शीर्षक से पता चलता है। निमंत्रण में तत्व बी(i) का सूचकांक 1 से 12 तक भिन्न होगा।

यदि आप प्रपत्र पर केवल सरणी B(N) के तत्वों के मान प्रदर्शित करना चाहते हैं, तो लूप के मुख्य भाग में एक कथन शामिल होगा:

सरणी तत्वों को देखकर उन पर कुछ क्रियाएं करने के लिए फॉर...नेक्स्ट लूप ऑपरेटर का उपयोग भी किया जाता है।

आइए देते हैं एक-आयामी सरणियों को संसाधित करने के उदाहरण।

उदाहरण 9.7 . सरणी बी में अधिकतम तत्व का निर्धारण(एम).

प्रारंभिक डेटा के इनपुट और परिणामों के आउटपुट को छोड़कर, हम संक्षेप में एल्गोरिदम का वर्णन करते हैं:

आइए एक वेरिएबल Bmax घोषित करें, जिसमें हम ऐरे के पहले तत्व का मान दर्ज करेंगे, और एक वेरिएबल Imax, जिसमें हम 1 असाइन करेंगे - ऐरे के पहले एलिमेंट का इंडेक्स।

एक लूप में, फॉर...नेक्स्ट ऑपरेटर का उपयोग करके, हम दूसरे से शुरू करते हुए, सरणी के सभी तत्वों को देखते हैं। यदि...तब ऑपरेटर का उपयोग करके, हम उनके मानों की तुलना Bmax चर में संग्रहीत मान से करते हैं।

यदि यह पता चलता है कि किसी सरणी तत्व का मान Bmax के मान से अधिक है, तो Bmax को इस तत्व का मान सौंपा गया है, और Imax का मान इस सरणी तत्व के सूचकांक को सौंपा गया है।

लूप के अंत के बाद, वेरिएबल Bmax में अधिकतम तत्व का मान होगा, और Imax में इसका इंडेक्स (संख्या) होगा।

एल्गोरिथम के इस भाग के लिए प्रोग्राम.

बीमैक्स = बी(1): आईमैक्स = 1

यदि B(i) > Bmax तो Bmax = B(i): Imax = i

उदाहरण 9.8. किसी सरणी के सकारात्मक तत्वों का योग, उत्पाद और संख्या निर्धारित करनाडी(एम).

चर:एस, पी, के - क्रमशः सकारात्मक तत्वों का योग, उत्पाद और संख्या।

एल्गोरिदमऐसी परिभाषा:

हम वेरिएबल एस और के को शून्य निर्दिष्ट करते हैं, और वेरिएबल पी को 1 असाइन करते हैं। एक नियम के रूप में, वे वेरिएबल जहां योग जमा होता है, यहां यह एस और के है, हमेशा लूप से पहले शून्य पर रीसेट हो जाते हैं, और वेरिएबल में जिस उत्पाद की गणना की जाती है उसे 1 सौंपा गया है।

For...Next लूप का उपयोग करते हुए, हम सरणी के सभी तत्वों से गुजरते हैं और जांचते हैं कि क्या वे सकारात्मक हैं (D(i) > 0)।

यदि यह पता चलता है कि तत्व सकारात्मक है, तो हम उसका मान योग S के मान में जोड़ते हैं और नए योग को उसी चर में संग्रहीत करते हैं। हम वेरिएबल P को तत्व के सकारात्मक मान से गुणा करते हैं और इसे वेरिएबल P में संग्रहीत भी करते हैं। और हम वेरिएबल K में 1 जोड़ते हैं और नए मान को उसी वेरिएबल में संग्रहीत करते हैं

कार्यक्रमएल्गोरिथम का यह भाग इस प्रकार दिखता है:

एस = 0: पी = 1: के = 0

यदि D(i) > 0 तब

S = S + D(i)' ऐसे जमा होती है रकम _

सरणी तत्वों के सकारात्मक मान D(i)

P = P*D(i)' सकारात्मक के उत्पाद की परिभाषा

'सरणी तत्व

K = K + 1' इस ऑपरेटर को COUNTER कहा जाता है, यहाँ यह है

' सकारात्मक सरणी तत्वों की संख्या को परिभाषित करता है

उदाहरण 9.9. विषम सरणी तत्वों का योग, उत्पाद, संख्या और औसत ज्ञात करनाडी(एम).

ऐसी परिभाषा के लिए यहां एक प्रोग्राम का एक अंश दिया गया है।

एस = 0: पी = 1: के = 0

यदि डी(आई) मॉड 2<>0 फिर

Ssr = S/k 'विषम तत्वों के औसत की गणना

इस प्रोग्राम खंड की तुलना उदाहरण 9.8 में दिए गए प्रोग्राम से करें। यह प्रोग्राम लगभग पूरी तरह से पिछले वाले को दोहराता है। केवल इफ स्टेटमेंट में स्थिति बदल गई है। कंडीशनडी(आई) मॉड 2<>0 का मतलब है कि हम सरणी D(i) के उन तत्वों की तलाश कर रहे हैं जो 2 से समान रूप से विभाज्य नहीं हैं, यानी विषम तत्व। यदि हम शर्त D(i) Mod 2 = 0 की जाँच करते हैं, तो हम सरणी के सम तत्वों का चयन करेंगे।

जैसा कि ज्ञात है, द्वारा विभाजन आधुनिकविभाजन का शेष भाग पूर्णांकों में देता है। उदाहरण के लिए, ऑपरेटर d = 34Mod4 को निष्पादित करने के बाद, वेरिएबल d 2 के बराबर होगा। इसलिए, 4 के गुणज वाले सरणी तत्वों का चयन करने के लिए, हमें शर्त D(i) Mod 4 = 0 की जांच करने की आवश्यकता है। शर्त होगी यदि हम ऐसे तत्वों की तलाश करते हैं जो अन्य संख्याओं के गुणज हैं तो समान बनें। 4 की जगह ये दूसरे नंबर लिखे जाएंगे.

उदाहरण 9.10. सरणी तत्व लिखनाआर(एन), 5 के गुणज, दूसरे ऐरे में और नए ऐरे को फॉर्म में आउटपुट करना।

आइए एक अन्य सरणी को निरूपित करें, उदाहरण के लिए, R5(N)। इस नई सरणी का आकार मूल सरणी के समान ही माना जाना चाहिए, क्योंकि चरम स्थिति में सभी तत्व 5 के गुणज हो सकते हैं।

समस्या एल्गोरिथ्म:

काउंटर k रीसेट करें. फॉर...नेक्स्ट लूप ऑपरेटर का उपयोग करके, हम सरणी आर(एन) के सभी तत्वों को देखते हैं।

हम यदि...तब ऑपरेटर का उपयोग करके और सरणी तत्व को मॉड द्वारा विभाजित करके 5 के गुणज के लिए प्रत्येक तत्व की जांच करते हैं।

यदि तत्व 5 का गुणज है, तो k=k+ 1 प्रकार के काउंटर का उपयोग करके हम 1 से शुरू करके सरणी R5(N) के सूचकांक बनाते हैं, और इसे इस अन्य सरणी -R5(N) में लिखते हैं।

यदि k शून्य से भिन्न है, तो प्रपत्र पर सरणी R5() प्रदर्शित करें।

यदि k शून्य के बराबर है, तो हम आउटपुट देते हैं: "5 से विभाज्य कोई तत्व नहीं है।"

कार्यक्रम खंड:

यदि R(i) Mod 5 तो k = k + 1: R5(k) = R(i)

यदि के<>0 फिर

"5 से विभाज्य कोई तत्व नहीं" प्रिंट करें

लूप्स को अन्य लूप्स के भीतर नेस्ट किया जा सकता है।

चलो काम करके दिखाते हैं स्थिर फंदा . नीचे दिया गया प्रोग्राम चक्र काउंटर i, j और k के मान प्रदर्शित करता है। I, j, k के आउटपुट से यह स्पष्ट हो जाता है कि नेस्टेड लूप कैसे निष्पादित होते हैं।

निजी उप frmCycle_DblClick()

स्केलमोड = 4 'इकाइयाँ - प्रतीक

I = 1 से 3 'बाहरी लूप के लिए

प्रिंट करें "i = "; मैं;

जे = 1 से 4' के लिए पहला नेस्टेड लूप

करंटएक्स = टेक्स्टविड्थ("i = 1") + 5

प्रिंट करें "जे = "; जे;

करंटएक्स = टेक्स्टविड्थ ("आई = 1 जे = 1") + 7

K = 1 से 5 '2रे नेस्टेड लूप के लिए

दिखाया गया फॉर्म (चित्र 1) सभी तीन लूपों के काउंटरों के आउटपुट के परिणाम दिखाता है: बाहरी लूप - काउंटर i, पहला नेस्टेड लूप - काउंटर j, और दूसरा, सबसे भीतरी लूप - काउंटर k। जैसा कि हम देखते हैं, सबसे धीमा काउंटर बाहरी लूप है(पोई), और "सबसे तेज़" अंतरतम लूप का काउंटर है (के अनुसार)।के).

प्रोग्राम को frmCicli फॉर्म पर बाईं माउस बटन पर डबल-क्लिक करने के बाद निष्पादित किया जाता है।

करंटएक्स, करंटवाई - फॉर्म गुण जो प्रिंट विधि का उपयोग करके जानकारी प्रदर्शित करने के लिए शुरुआती बिंदु के एक्स, वाई निर्देशांक निर्दिष्ट करते हैं (फॉर्म पर एक्स और वाई अक्षों के स्थान के लिए चित्र 1 देखें)।

TextWidth() एक फ़ंक्शन है जो फ़ंक्शन में निर्दिष्ट टेक्स्ट की चौड़ाई को दोहरे उद्धरण चिह्नों में एक तर्क के रूप में लौटाता है।

नेस्टेड लूप्स का उपयोग द्वि-आयामी सरणियों (मैट्रिसेस) को संसाधित करते समय किया जाता है। लेकिन कुछ कार्यों में, द्वि-आयामी सरणी के तत्वों के इनपुट और आउटपुट को छोड़कर, आप खुद को एक लूप तक सीमित कर सकते हैं। आइए मैट्रिक्स प्रोग्रामिंग के कुछ उदाहरण देखें।

उदाहरण 9.11. पूर्णांकों के मैट्रिक्स (द्वि-आयामी सरणी) का इनपुट और आउटपुटintA(एन).

आप मैट्रिक्स दर्ज कर सकते हैं पंक्तियों और स्तंभों द्वारा . यह आसान है - लाइन दर लाइन, यदि आप सरणी तत्वों के आउटपुट को दर्ज करने के तुरंत बाद फॉर्म में प्रोग्राम करते हैं।

मैट्रिक्स इनपुट और आउटपुटपंक्ति दर पंक्ति - खंड 1.

पूर्णांक के रूप में मंद एम, पूर्णांक के रूप में एन, पूर्णांक के रूप में आई, पूर्णांक के रूप में जे

मंद intA() पूर्णांक के रूप में 'एक गतिशील सरणी घोषित करें

M = Val(txtN.Text) ' M - पंक्तियों की संख्या

N = Val(txtN.Text) ' N - स्तंभों की संख्या

ReDim intA(M, N) As Integer ' सरणी को फिर से परिभाषित करें

i = 1 से M' के लिए मैं इसका मान पूरी तरह बरकरार रखूंगा

'जे पर नेस्टेड लूप निष्पादित नहीं किया जाएगा

प्रिंट करें ""; intA(i, j); 'आउटपुट लाइन दर लाइन

'प्रिंट करें' एक नई लाइन की शुरुआत में जाएं

कॉलम द्वारा मैट्रिक्स दर्ज करने के लिए, आपको बाहरी लूप को j (कॉलम संख्याओं को निर्दिष्ट करता है) में बनाना चाहिए, और आंतरिक लूप को i (पंक्ति संख्याओं को निर्दिष्ट करता है) में बनाना चाहिए।

मैट्रिक्स इनपुट और आउटपुटस्तंभों द्वारा – खंड 2.

PrY = 2500: वर्तमानY = PrY ' PrY प्रारंभ का Y निर्देशांक निर्धारित करता है

' प्रपत्र पर प्रत्येक कॉलम का पहला तत्व प्रदर्शित करता है

j = 1 से N' के लिए j अपना मान पूरी तरह बरकरार रखेगा

'आई पर नेस्टेड लूप निष्पादित नहीं किया जाएगा

intA (i, j) = InputBox("तत्व intA दर्ज करें(" & i & “,” & j & ")", _

"इनपुट मैट्रिक्स intA(" & M & "," & N & ")")

प्रिंट टैब(6 * जे); intA(i, j) 'कॉलम द्वारा आउटपुट

पहला तत्व प्रदर्शित करने के लिए currentY = PrY '

' अगला कॉलम

यह दूसरा प्रोग्राम खंड पहले खंड की पहली 5 पंक्तियों को नहीं दोहराता है। Tab(6 * j) फ़ंक्शन फॉर्म के बाएं किनारे से शुरू होकर, आउटपुट की शुरुआत को एक पंक्ति (वर्णों में) में सेट करता है। यहां निर्देशांक PrY 2500 ट्विप्स के बराबर है, लेकिन आप कोई अन्य मान चुन सकते हैं।

उदाहरण 9.12 . सरणी तत्व मानों को क्रमबद्ध करनावी(एन) आरोही।

सरणियों को क्रमबद्ध करने के लिए कई एल्गोरिदम हैं। यहाँ उनमें से एक है: नेस्टेड लूप का उपयोग करनाके लिए… अगलाहम पहले से अंतिम तक के तत्वों का चयन करते हैं, और उनमें से प्रत्येक की तुलना बाद के तत्वों से करते हैं; यदि यह पता चलता है कि अगला तत्व चयनित तत्व से छोटा है, तो हम उन्हें बदल देते हैं।

इस एल्गोरिथम को कार्यान्वित करने वाले प्रोग्राम का एक अंश:

i = 1 से N – 1 के लिए

जे = आई + 1 से एन के लिए

यदि वी(जे)< V(i) Then P = V(i): V(i) = V(j): V(j) = P

आइए हम कार्यक्रम के इस अंश को समझाएँ।

काउंटर i के साथ बाहरी लूप का उपयोग करके, हम बाद के तत्वों के साथ तुलना करने के लिए तत्व V(i) का चयन करते हैं। काउंटर j के साथ आंतरिक लूप तुलना के लिए V(j) के बाद के तत्वों का चयन करता है। प्रारंभिक मानj i+ 1 है। यह बाद वाले तत्वों में से पहला तत्व है।

तत्वों V(i) और V(j) के मूल्यों का आदान-प्रदान करने के लिए, हम कुछ वेरिएबल P पेश करते हैं, जिसमें हम अस्थायी रूप से सरणी के तत्वों में से एक के मूल्य को "छिपा" देते हैं (प्रोग्राम में यह V(i है) )). फिर तत्व V(i) को elementV(j) का मान निर्दिष्ट किया जाता है, और elementV(j) को मानV(i) निर्दिष्ट किया जाता है, जो वेरिएबलP में संग्रहीत होता है। यदि हम P में मान V(j) को "छिपा" देते हैं, तो मानों के आदान-प्रदान के लिए कोड इस प्रकार होगा: P = V(j): V(j) = V(i): V(i) = P .परिणाम नहीं बदलेगा.

को सरणी को अवरोही क्रम में क्रमबद्ध करें, सत्यापन के लिए शर्त को फॉर्म V(j) > V(i) में लिखना पर्याप्त है, यानी असमानता चिह्न को दूसरे में बदलें।

यदि सरणी संख्यात्मक नहीं है, लेकिन स्ट्रिंग है, और उपनाम सरणी तत्वों में दर्ज किए गए हैं, तो उदाहरण 9.12 में प्रोग्राम का उपयोग करके, आप उपनामों की सूची को वर्णानुक्रम में क्रमित कर सकते हैं। तथ्य यह है कि कंप्यूटर में प्रयुक्त वर्णमाला के अक्षरों के लिए, निम्नलिखित असमानताएँ सत्य हैं: A< Б < В < Г….< Я и т. д., поскольку числовые коды букв алфавита последовательно увеличиваются, начиная с А и до конца алфавита. Это же справедливо и для букв английского алфавита.

उदाहरण 9.13 . मैट्रिक्स के विषम स्तंभों के लिए सकारात्मक तत्वों के योग की गणना करनाएफ(एम, एन) और रकम को फॉर्म में आउटपुट करें।

प्रोग्राम एल्गोरिथम:

चरण 2 के साथ बाहरी लूप का उपयोग करते हुए, हम पहले कॉलम से शुरू करके, मैट्रिक्स के विषम कॉलमों का एक सूचकांक बनाते हैं।

हम योग S को रीसेट करते हैं, जिसमें सकारात्मक तत्वों का योग जमा हो जाएगा।

आंतरिक लूप में हम ऐरे तत्व के चिह्न की जाँच करते हैं।

यदि सरणी तत्व धनात्मक (> 0) है, तो हम योग S की गणना करते हैं।

आंतरिक लूप के अंत के बाद, हम फॉर्म पर योग S प्रदर्शित करते हैं।

टुकड़ा कार्यक्रमों:

जे = 1 से एन चरण 2 के लिए

यदि F(i, j) > 0 तो S = S + F(i, j)

"कॉलम योग" प्रिंट करें; जे; ":"; एस ' जे - कॉलम नंबर!

नेस्टेड लूप आपको व्यवस्थित करने की अनुमति देते हैं विकल्पों की गणना और उन समस्याओं को हल करें जिन्हें विश्लेषणात्मक रूप से हल नहीं किया जा सकता है। खोज के परिणामस्वरूप, समाधान विकल्प प्राप्त होते हैं, जिनमें से एक या अधिक का चयन किया जाता है जो समस्या की शर्तों को पूरा करते हैं।

उदाहरण 9.14. 1801 रूबल हैं। आप 31 रूबल में कितनी चॉकलेट खरीद सकते हैं? और 18 रूबल के लिए बन्स पर सारा पैसा पूरी तरह से खर्च हो जाएगा।

कार्यक्रम:

राशि = 1801

ऑलचॉकलेट्स = सम\31: ऑलबल्क्स = सम\18

i = 1 के लिए सभी चॉकलेट के लिए

J = 1 के लिए VseBulk के लिए

मूल्य = i * 31 + j * 18' कुल खरीद मूल्य

यदि कीमत = 1801 है तो

प्रिंट "चॉकलेट:"; मैं; टैब(19); "बुलोक:"; जे

आइए हम उस प्रोग्राम की व्याख्या करें जिसमें हम रूसी में नामित वेरिएबल्स का उपयोग करते हैं।

सबसे पहले, हम यह निर्धारित करते हैं कि अकेले चॉकलेट या सिर्फ रोल की अधिकतम संख्या कितनी है जिसे पूरी राशि के लिए खरीदा जा सकता है। हम चॉकलेट और रोल की संख्या के लिए खोजों की संख्या को सीमित करने के लिए ऑलचॉकलेट और ऑलबल्क्स के प्राप्त मूल्यों का उपयोग करते हैं। चॉकलेट की संख्या (i) और रोल की संख्या (j) के प्रत्येक मूल्य के लिए, हम उनकी खरीद के लिए कुल कीमत निर्धारित करते हैं। यदि परिकलित मूल्य 1801 है, तो चयनित विकल्प समस्या के समाधानों में से एक है।

टैब() फ़ंक्शन निर्दिष्ट करता है कि इस फ़ंक्शन के बाद आने वाली जानकारी फॉर्म के किनारे से किस स्थिति में प्रदर्शित की जाएगी। यदि टैब(19), तो 19वें स्थान से।

कार्यक्रम 3 संभावित खरीद विकल्प प्रदर्शित करता है:

चॉकलेट 7, रोल्स 88

चॉकलेट 25, रोल्स 57

चॉकलेट 43, बन्स 26

यदि आप स्पष्ट उत्तर देना चाहते हैं, तो आपको एक अतिरिक्त शर्त बनानी होगी। उदाहरण के लिए, "चॉकलेट की तुलना में कम बन खरीदे गए।" तब तीसरा विकल्प ही एकमात्र समाधान होगा।

ऐसी कई गणितीय समस्याएं हैं जिन्हें नेस्टेड लूप प्रोग्रामिंग का उपयोग करके आसानी से हल किया जा सकता है।

निर्णय लेने वाली संरचनाओं के अलावा, एक अन्य प्रकार की नियंत्रण संरचना भी होती है जिसे चक्र कहा जाता है।

चक्रएक एल्गोरिथम संरचना है जिसकी सहायता से ऑपरेटरों के ब्लॉक की एकाधिक पुनरावृत्ति कार्यान्वित की जाती है।

विज़ुअल बेसिक में तीन मुख्य प्रकार के लूप हैं, जिन्हें For:Next, Do:Loop, और While:Wend संरचनाओं का उपयोग करके कार्यान्वित किया जाता है।

के लिए: अगला लूप। इसका उपयोग तब किया जाता है जब कथनों के किसी दिए गए ब्लॉक की पुनरावृत्ति की संख्या पहले से ज्ञात हो। यह डिज़ाइन इस तरह दिखता है:

काउंटर के लिए = प्रारंभिक मूल्य से अंतिम मूल्य तक ऑपरेटर्स1 ऑपरेटर्स2 अगला [काउंटर]

जब उपरोक्त कथनों को पहली बार निष्पादित किया जाता है, तो काउंटर वेरिएबल को प्रारंभिक मान दिया जाता है, जिसके बाद दो विकल्प संभव होते हैं। यदि, कंडीशन काउंटर > अंतिम मान की जाँच के परिणामस्वरूप, True मान प्राप्त होता है, तो लूप समाप्त हो जाता है, और ब्लॉक ऑपरेटर्स1 और ऑपरेटर्स2 कभी निष्पादित नहीं होते हैं। दूसरी ओर, यदि स्थिति परीक्षण का परिणाम गलत है, तो इस स्थिति में स्टेटमेंट ब्लॉक पहली बार निष्पादित होते हैं, जिसके बाद लूप की शुरुआत में संक्रमण होता है। इसके बाद, काउंटर वैरिएबल का मान स्टेप कीवर्ड के बाद स्थित एक चरण द्वारा बढ़ाया जाता है (यदि यह अनुपस्थित है, तो चरण = 1 सेट है)। इसके बाद कंडीशन काउंटर > फाइनल वैल्यू आदि की सत्यता की फिर से जांच की जाती है, लूप का अंत उस समय होता है जब इस जांच का परिणाम वैल्यू ट्रू होता है।

कुछ अतिरिक्त शर्तें पूरी होने पर लूप को "आपातकालीन" रूप से समाप्त करना अक्सर आवश्यक होता है। इस मामले में, लूप के अंदर आपको सेवा वाक्यांश Exit:For का उपयोग करना चाहिए, जो आमतौर पर स्थित होता है नियंत्रण संरचना, उदाहरण के लिए:

यदि शर्त है तो बाहर निकलें

यदि स्थिति की जाँच का परिणाम सत्य है, तो लूप का निष्पादन समाप्त कर दिया जाएगा, और ऑपरेटर1 ब्लॉक को फिर से निष्पादित किया जाएगा, लेकिन ऑपरेटर2 ब्लॉक को नहीं।

करो: लूप. इसका उपयोग तब किया जाता है जब लूप बॉडी ऑपरेटरों की पुनरावृत्ति की संख्या पहले से अज्ञात होती है। इस डिज़ाइन की चार किस्में हैं। पहले दो का उपयोग करते समय, लूप या तो कई बार निष्पादित किया जाएगा या बिल्कुल नहीं।

कंडीशन लूप स्टेटमेंट तक करें

यदि स्थिति की जाँच का परिणाम गलत है, तो कथनों का ब्लॉक निष्पादित किया जाता है, अन्यथा सेवा शब्द लूप के बाद स्थित कथन में संक्रमण किया जाता है। दूसरी ओर, यदि शर्त का पहला परीक्षण परिणाम True देता है, तो लूप एक बार भी निष्पादित नहीं किया जाएगा।

जबकि कंडीशन लूप स्टेटमेंट करें

यदि शर्त सत्य है, तो कथनों का ब्लॉक निष्पादित किया जाता है, लेकिन यदि यह गलत है, यानी चेक का परिणाम गलत है, तो लूप एक बार भी निष्पादित नहीं किया जाएगा।

यदि अंतिम दो निर्माणों का उपयोग किया जाता है, तो लूप को कम से कम एक बार निष्पादित किया जाएगा।

कंडीशन तक स्टेटमेंट लूप करें

स्टेटमेंट ब्लॉक तब तक निष्पादित होता है जब तक स्थिति के परीक्षण का परिणाम गलत है, अन्यथा लूप समाप्त हो जाता है।

कंडीशन के दौरान स्टेटमेंट लूप करें

यदि शर्त झूठी है, तो कथनों का ब्लॉक निष्पादित किया जाता है, लेकिन यदि यह सत्य है, यानी। जाँच का परिणाम सत्य है, तो चक्र का अंत होता है।

जबकि लूप:वेंड। इसका उपयोग तब भी किया जाता है जब लूप बॉडी स्टेटमेंट की पुनरावृत्ति की संख्या पहले से अज्ञात होती है, और इसमें निम्नलिखित सिंटैक्स होता है:

जबकि शर्त वेंड बयान

यदि स्थिति की जाँच का परिणाम सत्य है, तो ऑपरेटरों का ब्लॉक निष्पादित किया जाता है, अन्यथा सेवा शब्द वेंड के बाद स्थित ऑपरेटर में संक्रमण किया जाता है। दूसरी ओर, यदि शर्त का पहला परीक्षण गलत परिणाम देता है, तो लूप एक बार भी निष्पादित नहीं किया जाएगा।

वीबीए. चक्रों का संगठन.

लूप स्टेटमेंट का उपयोग किसी क्रिया या क्रियाओं के समूह को निर्दिष्ट संख्या में दोहराने के लिए किया जाता है। दोहराव की संख्या (लूप पुनरावृत्तियों) को पूर्वनिर्धारित या गणना की जा सकती है।

VBA दो प्रकार की लूपिंग संरचनाओं का समर्थन करता है:

1. दोहराव की एक निश्चित संख्या के साथ लूप ( काउंटर किए गए लूप).
2. दोहराव की अनिश्चित संख्या के साथ लूप्स ( सशर्त लूप).

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

निश्चित चक्र

वीबीए एक निश्चित लूप को व्यवस्थित करने के लिए दो नियंत्रण संरचनाएं प्रदान करता है: फॉर ... नेक्स्ट (एक काउंटर के साथ लूप) और प्रत्येक के लिए ... नेक्स्ट (एक गणना के साथ लूप)।

ऑपरेटर के लिए...अगला यह एक विशिष्ट काउंटर लूप है जो दी गई संख्या में पुनरावृत्तियों को निष्पादित करता है। For...Next कथन का सिंटैक्स है:

के लिए<счетчик> = <начЗначение>वह<конЗначение>

<блок операторов>

अगला [<счетчик>]

For...Next ऑपरेटर का उपयोग करने का एक उदाहरण।

लिस्टिंग 1. ऑपरेटर के लिए... अगला

'कार्य: एक प्रोग्राम बनाएं जो उपयोगकर्ता से दो नंबर प्राप्त करता है।

' इन दो संख्याओं द्वारा निर्दिष्ट सीमा में सभी संख्याओं को जोड़ता है, और फिर

' परिणामी राशि प्रदर्शित करता है।

उप नमूना7()

डिम आई एज़ इंटीजर 'साइकिल काउंटर

मंद sStart 'प्रारंभिक काउंटर मान

मंद sEnd 'अंत काउंटर मूल्य

Dim sSum As Long' परिणामी योग

sStart = इनपुटबॉक्स ("पहला नंबर दर्ज करें:")

sEnd = इनपुटबॉक्स ("दूसरा नंबर दर्ज करें:")

sSum = 0

i के लिए = CInt(sStart) से CInt(sEnd)

sSum = sSum + i

अगला मैं

MsgBox "" & sStart & " से " & sEnd & " तक की संख्याओं का योग है: " & sSum

अंत उप

प्रत्येक के लिए लूप स्टेटमेंट...अगलाऑब्जेक्ट प्रकार ऑपरेटरों की श्रेणी से संबंधित है, अर्थात। मुख्य रूप से संग्रह पर लागू होता हैऑब्जेक्ट, साथ ही सरणियाँ . लूप की बॉडी को सरणी या संग्रह में तत्वों की संख्या के अनुरूप निश्चित संख्या में निष्पादित किया जाता है। प्रत्येक के लिए...अगला कथन प्रारूप:

प्रत्येक के लिए<элемент>में<группа> <блок операторов>अगला [<элемент>]

सशर्त लूप (अपरिभाषित लूप)

सशर्त लूप का उपयोग तब किया जाता है जब दोहराए गए कार्यों को केवल कुछ शर्तों के तहत करने की आवश्यकता होती है। पुनरावृत्तियों की संख्या परिभाषित नहीं है और सामान्य तौर पर शून्य के बराबर हो सकती है (विशेष रूप से, पूर्व शर्त वाले लूप के लिए)। VBA डेवलपर्स को सशर्त लूप व्यवस्थित करने के लिए कई नियंत्रण संरचनाएँ प्रदान करता है:

• चार प्रकार के डू..लूप्स, जो जांच की जाने वाली स्थिति के प्रकार और इस जांच को पूरा करने में लगने वाले समय में भिन्न होते हैं।
• निरंतर लूप जबकि... वेंड।

डू व्हाइल... लूप विशिष्ट है पूर्व शर्त के साथ लूप. लूप की बॉडी निष्पादित होने से पहले स्थिति की जाँच की जाती है। चक्र तब तक अपना कार्य जारी रखता है<условие>निष्पादित किया जाता है (अर्थात इसका मान True है)। चूँकि जाँच शुरुआत में की जाती है, लूप की बॉडी को कभी भी निष्पादित नहीं किया जा सकता है। जबकि करें... लूप प्रारूप:

जबकि ऐसा<условие>

<блок операторов>

कुंडली

लिस्टिंग 2. करते समय... लूप

'कार्य: एक प्रोग्राम बनाएं जिसके लिए उपयोगकर्ता इनपुट की आवश्यकता हो

'संख्याओं का एक मनमाना क्रम। इनपुट समाप्त किया जाना चाहिए

'प्रविष्ट विषम संख्याओं का योग 100 से अधिक होने पर ही।

उप नमूना8()

पूर्णांक के रूप में डिम ऑडसम 'विषम संख्याओं का योग

Dim OddStr As String 'विषम संख्याओं वाली एक स्ट्रिंग

डिम नंबर 'दर्ज किए गए नंबरों को स्वीकार करने के लिए

OddStr = '''' आउटपुट स्ट्रिंग आरंभीकरण

OddSum = 0 'OddSum आरंभ करें

ऑडसम करते समय करें< 100 ‘начало цикла

संख्या = इनपुटबॉक्स ("एक संख्या दर्ज करें:")

यदि (संख्या मॉड 2)<>0 फिर 'समता जांचें

OddSum = OddSum + Num 'विषम संख्याओं के योग का संचय

OddStr = OddStr और संख्या और ""

समाप्त यदि

कुंडली

'विषम संख्याओं वाली एक स्ट्रिंग प्रिंट करें

MsgBox प्रॉम्प्ट:=''विषम संख्याएँ:'' और OddStr

अंत उप

कथन के दौरान...लूप करेंसंगठन के लिए डिज़ाइन किया गयापोस्टकंडिशन के साथ लूप. लूप की बॉडी को कम से कम एक बार निष्पादित करने के बाद स्थिति की जाँच की जाती है। चक्र तब तक अपना कार्य जारी रखता है<условие>सत्य रहता है. करें... लूप करते समय प्रारूप:

करना<блок операторов>जबकि लूप<условие>

लिस्टिंग 3. पोस्टकंडीशन के साथ लूप

कार्य: खेल के लिए एक प्रोग्राम बनाएं "संख्या का अनुमान लगाएं।" कार्यक्रम यादृच्छिक होना चाहिए

' 1 से 1000 तक की रेंज में एक संख्या उत्पन्न करने का तरीका, उपयोगकर्ता को चाहिए

'इस संख्या का अनुमान लगाएं। प्रोग्राम दर्ज किए गए प्रत्येक नंबर के लिए एक संकेत प्रदर्शित करता है

' "करीब करीब"।

उप नमूना8()

रैंडमाइज़ टाइमर 'यादृच्छिक संख्या जनरेटर को प्रारंभ करें

'स्ट्रिंग' संदेश स्ट्रिंग के रूप में मंद संदेश

मंद गुप्त संख्या जितनी लंबी, उपयोक्ता संख्या उतनी ही भिन्न

आरंभ: सीक्रेटनंबर = राउंड(Rnd * 1000) 'कंप्यूटर जनित संख्या

उपयोगकर्ता संख्या = उपयोगकर्ता द्वारा दर्ज किया गया खाली 'नंबर

गेमप्ले करो

केस ट्रू का चयन करें

केस खाली है (उपयोगकर्ता संख्या): संदेश = "एक नंबर दर्ज करें"

केस उपयोगकर्ता संख्या > गुप्त संख्या: संदेश = "बहुत अधिक!"

केस उपयोगकर्ता संख्या< SecretNumber: msg = “Слишком мало!”

अंत चयन करें

उपयोगकर्ता संख्या = इनपुटबॉक्स (संकेत: = संदेश, शीर्षक: = "संख्या का अनुमान लगाएं")

उपयोगकर्ता संख्या को लूप करें<>गुप्त संख्या

'परीक्षा

यदि MsgBox ("फिर से चलाएँ?", vbहाँनहीं + vbप्रश्न, "आपने अनुमान लगाया!") = vbहाँ फिर

शुरू करने के लिए जाओ

समाप्त यदि

अंत उप

लूप तब तक करें... लूप करें और करें... लूप जब तक करें पहले चर्चा की गई सशर्त लूप के व्युत्क्रम हैं। सामान्य तौर पर, वे समान रूप से काम करते हैं, सिवाय इसके कि यदि स्थिति गलत है तो लूप का मुख्य भाग निष्पादित किया जाता है (अर्थात<условие>=झूठा). तब तक करें... लूप प्रारूप:

तब तक करो<условие> <блок операторов>कुंडली

करें... लूप तक लूप प्रारूप:

<блок операторов>

तब तक घुमाओ<условие>

व्यावहारिक कार्य:उल्टे लूप स्टेटमेंट का उपयोग करके लिस्टिंग 10 और 11 में प्रोग्राम को फिर से लिखें।

लूप जबकि...वेंड सशर्त लूप पर भी लागू होता है। यह ऑपरेटरडू व्हाइल... लूप संरचना के साथ पूरी तरह से सुसंगत है। जबकि...वेंड लूप प्रारूप:

जबकि<условие>

<блок операторов>

बीतना

इस ऑपरेटर की एक विशिष्ट विशेषता लूप बॉडी के पूरा होने (रुकावट) को मजबूर करने की असंभवता है (एग्जिट डू ऑपरेटर व्हाइल ... वेंड लूप में काम नहीं करता है)।

एक चक्र को बाधित करना

किसी पुनरावृत्ति को जल्दी समाप्त करने और लूप से बाहर निकलने के लिए, एग्ज़िट स्टेटमेंट का उपयोग किया जाता है। यह ऑपरेटर While... Wend को छोड़कर किसी भी चक्रीय संरचना में लागू होता है। लूप को तोड़ने के लिए Exit का उपयोग करने का सामान्य सिंटैक्स है:

<начало_цикла>

[<блок операторов1>]

बाहर निकलें (के लिए | करें)

[<блок операторов2>]

<конец_цикла>

जब एक्ज़िट स्टेटमेंट निष्पादित किया जाता है, तो लूप बाधित हो जाता है और स्टेटमेंट के बाद नियंत्रण स्टेटमेंट पर स्थानांतरित हो जाता है<конец_цикла>. लूप के मुख्य भाग में कई एक्ज़िट स्टेटमेंट हो सकते हैं।

लिस्टिंग 4. लूप से बलपूर्वक बाहर निकलें

उप नमूना9()

i = 1 से 10000000 के लिए

यदि i = 10 है तो 'Exit For' के लिए काउंटर 10 पर पहुंचने पर लूप से बाहर निकलें

अगला

श्रृंखला से सबक: “ विजुअल बेसिक.एनईएन में प्रोग्रामिंगस्कूली बच्चों के लिए"

आप कॉम्बोबॉक्स नियंत्रण से परिचित हो गए हैं.
इस पाठ में हम लूप ऑपरेटरों पर ध्यान केंद्रित करते हुए विजुअल बेसिक.नेट भाषा ऑपरेटरों का अपना अध्ययन जारी रखेंगे।
चक्रीय एल्गोरिथम संरचनाएँतीन प्रकार हैं:

1. काउंटर लूप जिसमें लूप की बॉडी निष्पादित होती है एक निश्चित राशिएक बार;
2. सरणियों या संग्रहों को संसाधित करने के लिए लूप;
3. सशर्त लूप, जिसमें लूप का मुख्य भाग तब निष्पादित होता है जब स्थिति सत्य होती है (या जब तक स्थिति सत्य नहीं हो जाती)।

इस पाठ में हम एक काउंटर के साथ लूप ऑपरेटर को देखेंगे (के लिए... अगला)। आइए इस ऑपरेटर का उपयोग करके एक प्रोजेक्ट लिखें।

चक्रकाउंटर के साथ के लिए। . . अगला t का उपयोग तब किया जाता है जब यह पहले से ज्ञात हो कि कितने दोहराव करने की आवश्यकता है।

ब्लॉक आरेख

ऑपरेटर का सामान्य दृश्य

काउंटर के लिए = स्टार्टवैल्यू से एंडवैल्यू लूप बॉडी नेक्स्ट [काउंटर]

ऑपरेटर का सिंटैक्स इस प्रकार है: फॉर कीवर्ड से शुरू होने वाली लाइन लूप का हेड है, और नेक्स्ट कीवर्ड वाली लाइन लूप का अंत है, उनके बीच स्टेटमेंट हैं जो लूप की बॉडी हैं।

फॉर ऑपरेटर को निष्पादित करने के लिए एल्गोरिदम। . . अगला

1. काउंटर वैरिएबल का मान स्टार्टवैल्यू के बराबर सेट किया गया है।
2. कंडीशन काउंटर की जांच की गई<= КонЗнач
3. यदि शर्त पूरी हो जाती है, तो लूप की बॉडी निष्पादित हो जाती है। काउंटर वैरिएबल को चरण मान द्वारा बदला जाता है: काउंटर = काउंटर + चरण।
4. जब काउंटर वैरिएबल मान ConValue तक पहुंचता है, तो लूप बाहर निकल जाता है और निम्नलिखित कथन निष्पादित होते हैं।

प्रोग्रामर Exit For निर्माण का उपयोग करके लूप से समय से पहले बाहर निकलने का आयोजन कर सकता है। इस स्थिति में, लूप स्वचालित रूप से बाहर निकल जाता है और नियंत्रण लूप के बाद अगले कमांड पर स्थानांतरित हो जाता है।

परियोजना "जमा पर आय"

एक प्रोजेक्ट लिखें जो जमा पर आय की गणना करता है और सरल और चक्रवृद्धि ब्याज की गणना प्रदान करता है। जमा अवधि के अंत में साधारण ब्याज अर्जित किया जाता है, चक्रवृद्धि ब्याज मासिक रूप से अर्जित किया जाता है और प्रारंभिक जमा राशि में जोड़ा जाता है, और अगले महीने नई राशि पर ब्याज अर्जित किया जाता है। अनुशंसित प्रपत्र चित्र में दिखाया गया है।

निष्पादन तकनीक

इस ट्यूटोरियल में दिखाया गया है कि कोड को निर्दिष्ट संख्या में दोहराने के लिए फॉर...नेक्स्ट लूप का उपयोग कैसे करें।

किसी प्रक्रिया की कोई भी क्रिया जो एक निर्दिष्ट संख्या में बार-बार दोहराई जाती है या जब तक कोई शर्त पूरी नहीं हो जाती या पूरी नहीं हो जाती, कहलाती है चक्र .

लूप संरचना में संलग्न सभी कथनों को एक बार निष्पादित करने की प्रक्रिया को कहा जाता है पाश पुनरावृत्ति.

लूप संरचनाएँ जो हमेशा एक निर्दिष्ट संख्या में निष्पादित होती हैं, कहलाती हैं पुनरावृत्तियों की एक निश्चित संख्या के साथ लूप. अन्य प्रकार की लूप संरचनाएं कुछ स्थितियों के आधार पर भिन्न-भिन्न बार दोहराती हैं। ऐसे चक्र कहलाते हैं अनिश्चितकालीन चक्र.

लूप के आरंभ और अंत के बीच स्थित कथनों के ब्लॉक को कहा जाता है "लूप बॉडी".

सबसे सरल लूप संरचना है निश्चित चक्र .

के लिए..अगला लूप

सिंटेक्स

के लिए विरोध करना = शुरूको अंत
बयान
अगला [ विरोध करना]

काउंटर - कोई भी वीबीए संख्यात्मक चर
प्रारंभ - कोई भी संख्यात्मक अभिव्यक्ति जो काउंटर चर के लिए प्रारंभिक मान को परिभाषित करती है
अंत - एक संख्यात्मक अभिव्यक्ति जो काउंटर वैरिएबल के लिए अंतिम मान को परिभाषित करती है

डिफ़ॉल्ट रूप से VBA एक वेरिएबल बढ़ाता है विरोध करनाहर बार जब कथन लूप में निष्पादित होते हैं तो 1 से। आप एक अलग मान सेट कर सकते हैं ( SterSize- कोई भी संख्यात्मक अभिव्यक्ति) जिसके द्वारा यह बदल जाएगा विरोध करना.

कीवर्ड अगलावीबीए को बताता है कि लूप के अंत तक पहुंच गया है। वैकल्पिक चर विरोध करनाकीवर्ड के बाद अगलाएक ही चर होना चाहिए विरोध करना, जो कीवर्ड के बाद निर्दिष्ट किया गया था के लिएलूप संरचना की शुरुआत में.

नीचे सबसे सरल लूप की सूची दी गई है के लिए..अगला, जो 1 से 10 तक की संख्याओं का योग गिनता है:

और अब साइकिल के लिए दो विकल्प के लिए..अगलाएक के अलावा किसी अन्य लूप चरण का उपयोग करना:

ध्यान देना!चक्र काउंटर को कम करते समय के लिए..अगलालूप तब तक निष्पादित होता है जब तक काउंटर वैरिएबल अंतिम मान से अधिक या उसके बराबर होता है, और जब लूप काउंटर बढ़ाया जाता है, तो लूप तब तक निष्पादित होता है जब तक काउंटर वैरिएबल अंतिम मान से कम या उसके बराबर होता है।

प्रत्येक के लिए लूप..अगला

चक्र प्रत्येक के लिए..अगलासाइकिल काउंटर का उपयोग नहीं करता. साइकिल प्रत्येक के लिए..अगलाकिसी विशेष समूह में जितनी बार तत्व होते हैं उतनी बार निष्पादित होते हैं, जैसे वस्तुओं का संग्रह या एक सरणी (जिस पर बाद में चर्चा की जाएगी)। दूसरे शब्दों में, चक्र प्रत्येक के लिए..अगलासमूह में प्रत्येक तत्व के लिए एक बार निष्पादित किया जाता है।

सिंटेक्स

प्रत्येक के लिए तत्वमें समूह
बयान
अगला [ तत्व]

तत्व - एक चर जिसका उपयोग किसी विशिष्ट समूह के सभी तत्वों को पुनरावृत्त करने के लिए किया जाता है
समूह एक संग्रह वस्तु या सरणी है
कथन - एक, अनेक या कोई VBA कथन (लूप बॉडी)।