VBA இல் சுழல்கள்

VBA நிரல் ஒரே மாதிரியான செயல்களை ஒரு வரிசையில் பல முறை செய்ய வேண்டிய சூழ்நிலைகள் உள்ளன (அதாவது, அதே குறியீட்டை பல முறை செய்யவும்). VBA சுழல்களைப் பயன்படுத்தி இதைச் செய்யலாம்.

VBA சுழல்கள் அடங்கும்:

• சைக்கிள்
• லூப் செய்யும் போது செய்யுங்கள்
• வரை சுழற்சி செய்யுங்கள்

அடுத்து, இந்த சுழற்சிகள் ஒவ்வொன்றையும் நாம் கூர்ந்து கவனிப்போம்.

விஷுவல் பேசிக்கில் லூப் ஆபரேட்டருக்கு

லூப் ஆபரேட்டரின் அமைப்பு தி விஷுவல் பேசிக் இரண்டு வடிவங்களில் ஒன்றில் ஒழுங்கமைக்கப்படலாம்: ஒரு வளையமாக இதற்கு... அடுத்து அல்லது ஒரு வளையமாக ஒவ்வொரு.

சுழற்சி “அடுத்து…”

சைக்கிள் இதற்கு... அடுத்து கொடுக்கப்பட்ட வரம்பிலிருந்து மதிப்புகளை தொடர்ச்சியாக எடுக்கும் மாறியைப் பயன்படுத்துகிறது. மாறியின் மதிப்பின் ஒவ்வொரு மாற்றத்திலும், சுழற்சியின் உடலில் மூடப்பட்ட செயல்கள் செய்யப்படுகின்றன. ஒரு எளிய உதாரணத்திலிருந்து இதைப் புரிந்துகொள்வது எளிது:

ஐ = 1 முதல் 10 வரை மொத்தம் = மொத்தம் + iArray(i) அடுத்து i

இந்த எளிய சுழற்சியில் இதற்கு... அடுத்து மாறி பயன்படுத்தப்படுகிறது i, இது 1, 2, 3, … 10 ஆகிய மதிப்புகளை தொடர்ச்சியாக எடுக்கும், மேலும் இந்த ஒவ்வொரு மதிப்புக்கும், லூப்பில் உள்ள VBA குறியீடு செயல்படுத்தப்படுகிறது. இவ்வாறு, இந்த வளையமானது வரிசையின் கூறுகளை தொகுக்கிறது. iArray மாறியில் மொத்த.

மேலே உள்ள எடுத்துக்காட்டில், லூப் அதிகரிப்பு குறிப்பிடப்படவில்லை, எனவே மாறியை அதிகரிக்க i 1 முதல் 10 வரை, இயல்புநிலை அதிகரிப்பு ஆகும் 1… இருப்பினும், சில சந்தர்ப்பங்களில் லூப்பிற்கு வெவ்வேறு அதிகரிப்பு மதிப்புகளைப் பயன்படுத்துவது அவசியம். முக்கிய சொல்லைப் பயன்படுத்தி இதைச் செய்யலாம் படிபின்வரும் எளிய எடுத்துக்காட்டில் காட்டப்பட்டுள்ளது.

d = 0 முதல் 10 படி 0.1 dTotal = dTotal + d அடுத்த d

மேலே உள்ள எடுத்துக்காட்டில், அதிகரிப்பு படி சமமாக அமைக்கப்பட்டுள்ளது 0.1, பின்னர் மாறி dTotal சுழற்சியின் ஒவ்வொரு மறுபடியும் 0.0, 0.1, 0.2, 0.3,… 9.9, 10.0 மதிப்புகளை எடுக்கும்.

VBA இல் லூப் படியைத் தீர்மானிக்க, நீங்கள் எதிர்மறை மதிப்பைப் பயன்படுத்தலாம், எடுத்துக்காட்டாக, இது போன்றது:

i = 10 முதல் 1 படி -1 iArray(i) = i Next i

இங்கே அதிகரிப்பு உள்ளது -1, அதனால் மாறி i சுழற்சியின் ஒவ்வொரு மறுபடியும் 10, 9, 8, … 1 மதிப்புகளைப் பெறுகிறது.

லூப் "ஒவ்வொருவருக்கும்"

சைக்கிள் ஒவ்வொரு ஒரு சுழற்சியைப் போன்றது இதற்கு... அடுத்து, ஆனால் எதிர் மாறிக்கான மதிப்புகளின் வரிசையை மீண்டும் செய்வதற்கு பதிலாக, லூப் ஒவ்வொரு குறிப்பிட்ட பொருள்களின் குழுவில் உள்ள ஒவ்வொரு பொருளுக்கும் செயல்களின் தொகுப்பைச் செய்கிறது. பின்வரும் எடுத்துக்காட்டில், ஒரு வளையத்தைப் பயன்படுத்துதல் ஒவ்வொரு தற்போதைய எக்செல் பணிப்புத்தகத்தில் உள்ள அனைத்து தாள்களையும் கணக்கிடுகிறது:

ஒர்க்ஷீட்களில் உள்ள ஒவ்வொரு wஷீட்டிற்கும் ஒர்க் ஷீட்டாக மங்கலான wheet

லூப் குறுக்கீடு அறிக்கை "வெளியேறு"

ஆபரேட்டர் வெளியேறு சுழற்சியை குறுக்கிட பயன்படுகிறது. குறியீட்டில் இந்த அறிக்கையை எதிர்கொண்டவுடன், நிரல் லூப்பின் செயல்பாட்டை முடித்து, இந்த வளையத்திற்குப் பிறகு உடனடியாக குறியீட்டில் உள்ள அறிக்கைகளை செயல்படுத்துகிறது. எடுத்துக்காட்டாக, ஒரு வரிசையில் ஒரு குறிப்பிட்ட மதிப்பைத் தேட இதைப் பயன்படுத்தலாம். இதைச் செய்ய, ஒரு வளையத்தைப் பயன்படுத்தி, வரிசையின் ஒவ்வொரு உறுப்பும் ஸ்கேன் செய்யப்படுகிறது. தேவையான உறுப்பு கண்டுபிடிக்கப்பட்டவுடன், மீதமுள்ளவற்றைப் பார்க்க வேண்டிய அவசியமில்லை - சுழற்சி குறுக்கிடப்படுகிறது.

ஆபரேட்டர் விண்ணப்பம் வெளியேறு பின்வரும் எடுத்துக்காட்டில் நிரூபிக்கப்பட்டுள்ளது. இங்கே லூப் 100 வரிசை உள்ளீடுகளை மீண்டும் செய்கிறது மற்றும் ஒவ்வொன்றையும் மாறியின் மதிப்புடன் ஒப்பிடுகிறது dVal… பொருத்தம் கண்டறியப்பட்டால், லூப் நிறுத்தப்படும்:

ஐ = 1 முதல் 100 வரை என்றால் dValues(i) = dVal பிறகு IndexVal = i Exit for End எனில் அடுத்து i

விஷுவல் பேசிக்கில் டூ வைல் லூப்

சைக்கிள் போது செய்யுங்கள் குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் வரை குறியீட்டின் தொகுதியை செயல்படுத்துகிறது. பின்வருபவை ஒரு செயல்முறையின் எடுத்துக்காட்டு சப், இதில் லூப்பைப் பயன்படுத்துகிறது போது செய்யுங்கள் 1000க்கு மிகாமல் இருக்கும் ஃபைபோனச்சி எண்கள் தொடர்ச்சியாகக் காட்டப்படும்:

'துணை செயல்முறை வெளியீடுகள் ஃபைபோனச்சி எண்கள் 1000க்கு மிகாமல் Sub Fibonacci() Dim i As Integer 'கவுண்டர்' வரிசையில் உள்ள தனிமத்தின் நிலையைக் குறிக்கும் 'dim iFib As Integer' வரிசையின் தற்போதைய மதிப்பைச் சேமிக்கிறது Dim iFib_Next As Integer 'அடுத்த மதிப்பைச் சேமிக்கிறது வரிசையின் Dim iStep As Integer 'அடுத்த அதிகரிப்பின் அளவை சேமிக்கிறது 'இனிஷியலைஸ் மாறிகள் i மற்றும் iFib_Next i = 1 iFib_Next = 0 'Do while loop ஆனது 'தற்போதைய Fibonacci எண் 1000 ஐ விட அதிகமாக இருக்கும் போது < iFib_1000 ஐ விட அதிகமாக இருக்கும் வரை இயக்கப்படும். 1 பிறகு 'முதல் உறுப்புக்கான சிறப்பு வழக்கு iStep = 1 iFib = 0 மற்றது' 'வரிசையின் தற்போதைய மதிப்பை மேலெழுதுவதற்கு முன் அடுத்த அதிகரிப்பின் அளவைச் சேமிக்கவும் iStep = iFib iFib = iFib_Next End' என்றால் 'தற்போதைய Fibonacci எண்ணை A நெடுவரிசையில் அச்சிடவும். குறியீட்டு i செல்கள் (i , 1) கொண்ட வரிசையில் செயலில் உள்ள பணித்தாள். மதிப்பு = iFib 'அடுத்த Fibonacci எண்ணைக் கணக்கிட்டு, உறுப்பு நிலை குறியீட்டை 1 iFib_Next = iFib + iStep i = i + 1 லூப் எண்ட் சப் மூலம் அதிகரிக்கவும்.

கொடுக்கப்பட்ட எடுத்துக்காட்டில், நிபந்தனை iFib_Next < 1000 சுழற்சியின் தொடக்கத்தில் சரிபார்க்கப்பட்டது. எனவே, முதல் மதிப்பு என்றால் iFib_அடுத்து 1000 க்கு மேல் இருந்தால், லூப் ஒருபோதும் செயல்படுத்தப்படாது.

ஒரு வளையத்தை செயல்படுத்த மற்றொரு வழி போது செய்யுங்கள் - நிபந்தனையை தொடக்கத்தில் அல்ல, ஆனால் சுழற்சியின் முடிவில் வைக்கவும். இந்த வழக்கில், நிபந்தனை பூர்த்தி செய்யப்பட்டதா என்பதைப் பொருட்படுத்தாமல், லூப் ஒரு முறையாவது செயல்படுத்தப்படும்.

திட்டவட்டமாக, அத்தகைய சுழற்சி போது செய்யுங்கள் இறுதியில் சரிபார்க்க வேண்டிய நிபந்தனை இப்படி இருக்கும்:

செய்... iFib_Next < 1000 இல் லூப் செய்யவும்

விஷுவல் பேசிக்கில் "டூ வரை"

சைக்கிள் வரை செய்யுங்கள் சுழற்சிக்கு மிகவும் ஒத்திருக்கிறது போது செய்யுங்கள்: குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் வரை லூப்பின் உடலில் உள்ள குறியீட்டின் தொகுதி மீண்டும் மீண்டும் செயல்படுத்தப்படுகிறது (நிபந்தனை வெளிப்பாட்டின் விளைவு உண்மை) அடுத்த நடைமுறையில் சப் ஒரு சுழற்சியைப் பயன்படுத்தி வரை செய்யுங்கள் ஒரு நெடுவரிசையில் உள்ள அனைத்து கலங்களிலிருந்தும் மதிப்புகளை மீட்டெடுக்கவும் A நிரல் வெற்று கலத்தை சந்திக்கும் வரை பணித்தாள்:

iRow = 1 ஐஸ்ஈம்ப்டி வரை செய்யுங்கள்(செல்கள்(iRow, 1)) 'தற்போதைய கலத்தின் மதிப்பு வரிசையில் சேமிக்கப்படுகிறது dCellValues ​​dCellValues(iRow) = Cells(iRow, 1).மதிப்பு iRow = iRow + 1 Loop

மேலே உள்ள எடுத்துக்காட்டில், நிபந்தனை வெறுமை(கலங்கள்(iRow, 1)) கட்டமைப்பின் தொடக்கத்தில் அமைந்துள்ளது வரை செய்யுங்கள், எனவே எடுக்கப்பட்ட முதல் செல் காலியாக இல்லாவிட்டால் லூப் ஒரு முறையாவது செயல்படுத்தப்படும்.

இருப்பினும், லூப் எடுத்துக்காட்டுகளில் காட்டப்பட்டுள்ளது போது செய்யுங்கள், சில சூழ்நிலைகளில் நிபந்தனை வெளிப்பாட்டின் ஆரம்ப முடிவைப் பொருட்படுத்தாமல், குறைந்தபட்சம் ஒரு முறை வளையத்தை இயக்குவது அவசியம். இந்த வழக்கில், நிபந்தனை வெளிப்பாடு வளையத்தின் முடிவில் வைக்கப்பட வேண்டும், இது போன்றது:

செய்... லூப் வரை காலியாக இருக்கும்(செல்கள்(iRow, 1))