విషయ సూచిక
VBA ప్రోగ్రామ్‌కు ఒకే విధమైన చర్యలను వరుసగా అనేకసార్లు నిర్వహించాల్సిన అవసరం ఉన్న సందర్భాలు ఉన్నాయి (అనగా, అదే బ్లాక్ కోడ్‌ను చాలాసార్లు పునరావృతం చేయండి). ఇది VBA లూప్‌లను ఉపయోగించి చేయవచ్చు.
VBA లూప్‌లు ఉన్నాయి:
తరువాత, మేము ఈ చక్రాలలో ప్రతిదానిని నిశితంగా పరిశీలిస్తాము.
విజువల్ బేసిక్లో లూప్ ఆపరేటర్ కోసం
లూప్ ఆపరేటర్ యొక్క నిర్మాణం మా విజువల్ బేసిక్లో రెండు రూపాల్లో ఒకదానిలో నిర్వహించవచ్చు: లూప్‌గా కోసం... తదుపరి లేదా లూప్‌గా ప్రతి.
సైకిల్ “కోసం … తదుపరి”
చక్రం కోసం... తదుపరి ఇచ్చిన పరిధి నుండి వరుసగా విలువలను తీసుకునే వేరియబుల్‌ని ఉపయోగిస్తుంది. వేరియబుల్ యొక్క విలువ యొక్క ప్రతి మార్పుతో, చక్రం యొక్క శరీరంలో మూసివేయబడిన చర్యలు నిర్వహించబడతాయి. ఇది ఒక సాధారణ ఉదాహరణ నుండి అర్థం చేసుకోవడం సులభం:
i = 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 తదుపరి i కోసం
ఇక్కడ ఇంక్రిమెంట్ ఉంది -1, కాబట్టి వేరియబుల్ i చక్రం యొక్క ప్రతి పునరావృతం 10, 9, 8, … 1 విలువలను తీసుకుంటుంది.
లూప్ “ప్రతి ఒక్కరికి”
చక్రం ప్రతి ఒక చక్రాన్ని పోలి ఉంటుంది కోసం... తదుపరి, కానీ కౌంటర్ వేరియబుల్, లూప్ కోసం విలువల క్రమాన్ని పునరావృతం చేయడానికి బదులుగా ప్రతి పేర్కొన్న వస్తువుల సమూహంలోని ప్రతి వస్తువు కోసం చర్యల సమితిని నిర్వహిస్తుంది. కింది ఉదాహరణలో, లూప్ ఉపయోగించి ప్రతి ప్రస్తుత Excel వర్క్‌బుక్‌లోని అన్ని షీట్‌లను గణిస్తుంది:
వర్క్‌షీట్‌లలోని ప్రతి wషీట్‌కి వర్క్‌షీట్‌గా మసకబారడం
లూప్ అంతరాయ ప్రకటన “ఎగ్జిట్ ఫర్”
ఆపరేటర్ నిష్క్రమించు చక్రం అంతరాయం కలిగించడానికి ఉపయోగిస్తారు. కోడ్‌లో ఈ ప్రకటన కనిపించిన వెంటనే, ప్రోగ్రామ్ లూప్ యొక్క అమలును ముగించి, ఈ లూప్ తర్వాత వెంటనే కోడ్‌లో ఉన్న స్టేట్‌మెంట్‌ల అమలుకు కొనసాగుతుంది. ఉదాహరణకు, శ్రేణిలో నిర్దిష్ట విలువ కోసం శోధించడానికి దీనిని ఉపయోగించవచ్చు. దీన్ని చేయడానికి, లూప్ ఉపయోగించి, శ్రేణిలోని ప్రతి మూలకం స్కాన్ చేయబడుతుంది. అవసరమైన మూలకం కనుగొనబడిన వెంటనే, మిగిలిన వాటి ద్వారా చూడవలసిన అవసరం లేదు - చక్రం అంతరాయం కలిగిస్తుంది.
ఆపరేటర్ అప్లికేషన్ నిష్క్రమించు కింది ఉదాహరణలో ప్రదర్శించబడింది. ఇక్కడ లూప్ 100 కంటే ఎక్కువ శ్రేణి ఎంట్రీలను పునరావృతం చేస్తుంది మరియు ప్రతి ఒక్కటి వేరియబుల్ విలువతో పోలుస్తుంది dVal… సరిపోలిక కనుగొనబడితే, లూప్ నిలిపివేయబడుతుంది:
i = 1 నుండి 100 వరకు ఉంటే dValues(i) = dVal అప్పుడు IndexVal = i తదుపరి ఐతే ముగింపు కోసం నిష్క్రమించండి
విజువల్ బేసిక్లో డూ వైల్ లూప్
చక్రం అయితే చేయండి పేర్కొన్న షరతుకు అనుగుణంగా ఉన్నంత వరకు కోడ్ బ్లాక్‌ని అమలు చేస్తుంది. కిందిది ఒక ప్రక్రియ యొక్క ఉదాహరణ సబ్, దీనిలో లూప్ ఉపయోగించి అయితే చేయండి 1000 మించని ఫైబొనాక్సీ సంఖ్యలు వరుసగా ప్రదర్శించబడతాయి:
'సబ్ ప్రొసీజర్ అవుట్‌పుట్‌లు 1000 సబ్ ఫిబొనాక్సీ() డిమ్ ఐ యాజ్ ఇంటెజర్ 'కౌంటర్ డిమ్ ఐఫైబ్ యాజ్ ఇంటెజర్ సీక్వెన్స్‌లోని ప్రస్తుత విలువను డిమ్ iFib_Next పూర్ణాంకం వలె నిల్వ చేస్తుంది 'తదుపరి విలువను నిల్వ చేస్తుంది సీక్వెన్స్ యొక్క Dim iStep As Integer 'తదుపరి ఇంక్రిమెంట్ యొక్క పరిమాణాన్ని నిల్వ చేస్తుంది 'ఇనీషియలైజ్ వేరియబుల్స్ i మరియు iFib_Next i = 1 iFib_Next = 0 'Do while లూప్ 'ప్రస్తుత ఫైబొనాక్సీ సంఖ్య 1000 కంటే ఎక్కువగా ఉంటే 1000 కంటే ఎక్కువ ఉంటే < iFib_Next 1 ఆపై 'మొదటి మూలకం iStep కోసం ప్రత్యేక సందర్భం iStep = 1 iFib = 0 'ఇలా 'క్రమం యొక్క ప్రస్తుత విలువ iStep = iFib iFib = iFib_Next End 'అయితే 'ప్రస్తుత Fibonacci నంబర్‌ను A కాలమ్‌లో ముద్రించండి యాక్టివ్ వర్క్‌షీట్ 'ఇండెక్స్ i సెల్స్‌తో (i , 1) వరుసలో ఉంది. విలువ = iFib 'తదుపరి ఫిబొనాక్సీ సంఖ్యను లెక్కించండి మరియు మూలకం స్థాన సూచికను 1 iFib_Next = iFib + iStep i = i + 1 లూప్ ఎండ్ సబ్ పెంచండి
ఇచ్చిన ఉదాహరణలో, పరిస్థితి iFib_Next < 1000 లూప్ ప్రారంభంలో తనిఖీ చేయబడింది. కాబట్టి, మొదటి విలువ ఉంటే iFib_తదుపరి 1000 కంటే ఎక్కువ ఉంటే, లూప్ ఎప్పటికీ అమలు చేయబడదు.
లూప్‌ను అమలు చేయడానికి మరొక మార్గం అయితే చేయండి - పరిస్థితిని ప్రారంభంలో కాకుండా లూప్ చివరిలో ఉంచండి. ఈ సందర్భంలో, షరతుతో సంబంధం లేకుండా కనీసం ఒక్కసారైనా లూప్ అమలు చేయబడుతుంది.
క్రమపద్ధతిలో, అటువంటి చక్రం అయితే చేయండి ముగింపులో తనిఖీ చేయవలసిన పరిస్థితి ఇలా కనిపిస్తుంది:
చేయండి ... iFib_Next < 1000 అయితే లూప్ చేయండి
విజువల్ బేసిక్లో "డూ వరకు"
చక్రం వరకు చేయండి చక్రం చాలా పోలి ఉంటుంది అయితే చేయండి: లూప్ యొక్క బాడీలో కోడ్ యొక్క బ్లాక్ పేర్కొన్న షరతును చేరుకునే వరకు మళ్లీ మళ్లీ అమలు చేయబడుతుంది (నియత వ్యక్తీకరణ ఫలితం ట్రూ) తదుపరి విధానంలో సబ్ ఒక చక్రం ఉపయోగించి వరకు చేయండి నిలువు వరుసలోని అన్ని సెల్‌ల నుండి విలువలను తిరిగి పొందండి A కాలమ్ ఖాళీ గడిని ఎదుర్కొనే వరకు వర్క్‌షీట్:
iRow = 1 డు ఐసిఎంప్టీ వరకు (సెల్‌లు(iRow, 1)) 'ప్రస్తుత సెల్ విలువ శ్రేణిలో నిల్వ చేయబడుతుంది dCellValues dCellValues(iRow) = సెల్‌లు(iRow, 1).విలువ iRow = iRow + 1 లూప్
పై ఉదాహరణలో, పరిస్థితి ఖాళీ (కణాలు(iRow, 1)) నిర్మాణం ప్రారంభంలో ఉంది వరకు చేయండి, కాబట్టి తీసిన మొదటి సెల్ ఖాళీగా లేకుంటే లూప్ కనీసం ఒక్కసారైనా అమలు చేయబడుతుంది.
అయితే, లూప్ ఉదాహరణలలో చూపిన విధంగా అయితే చేయండి, కొన్ని పరిస్థితులలో షరతులతో కూడిన వ్యక్తీకరణ యొక్క ప్రారంభ ఫలితంతో సంబంధం లేకుండా, లూప్‌ని కనీసం ఒక్కసారైనా అమలు చేయడం అవసరం. ఈ సందర్భంలో, షరతులతో కూడిన వ్యక్తీకరణను లూప్ చివరిలో ఇలా ఉంచాలి:
డు ... లూప్ వరకు ఖాళీ (సెల్‌లు(iRow, 1))