ఈ కథనం జావాస్క్రిప్ట్‌లో forEach లూప్‌ను ఆపే విధానాన్ని వివరిస్తుంది.
ప్రతి ఒక్కరికి జావాస్క్రిప్ట్‌ను ఎలా ఆపాలి?
ప్రోగ్రామ్ యొక్క నిర్దిష్ట అవసరాలపై ఆధారపడి, ప్రోగ్రామింగ్‌లో లూప్‌ను ఆపడానికి అనేక మార్గాలు ఉన్నాయి. ఉదాహరణకు, మీరు లూప్ టెర్మినేషన్ కండిషన్ లేదా బ్రేక్ స్టేట్‌మెంట్‌ని ఉపయోగించవచ్చు “ బ్రేక్ ' లేదా ' బయటకి దారి ”ఒక నిర్దిష్ట షరతు నెరవేరినప్పుడు లూప్‌ను ఆపడానికి. అయితే, సమస్య ఏమిటంటే, ' ప్రతి ” లూప్ ఈ స్టేట్‌మెంట్‌లను ఉపయోగిస్తున్నప్పుడు ఎర్రర్‌ను విసురుతుంది.
ఉదాహరణ 1: ప్రతి జావాస్క్రిప్ట్ లూప్‌లో “బ్రేక్” ఉపయోగించండి
ఆపడానికి ప్రయత్నిద్దాం' ప్రతి 'లూప్ ఉపయోగించి' బ్రేక్ ' ప్రకటన. ముందుగా, బేసి సంఖ్యల శ్రేణిని సృష్టించండి:
శ్రేణి ఉంది = [ ఒకటి , 3 , 5 , 7 , 9 , పదకొండు , 13 , పదిహేను ] ;
శ్రేణిని పునరావృతం చేయడానికి forEach లూప్‌ని ఉపయోగించండి. మూలకం ఉంటే ' 5 ” పునరావృతం సమయంలో శ్రేణిలో సంభవిస్తుంది, లూప్‌ను ఆపండి:
అమరిక. ప్రతి ( మూలకం => {
ఉంటే ( మూలకం == 5 ) {
బ్రేక్ ;
}
} ) ;
forEach లూప్‌లో బ్రేక్ స్టేట్‌మెంట్ పనిచేయడం లేదని చూడవచ్చు:
ఉదాహరణ 2: ప్రతి జావాస్క్రిప్ట్ లూప్‌లో “EXIT” ఉపయోగించండి
'ని ఉపయోగించి లూప్‌ను ఆపడానికి ప్రయత్నించండి బయటకి దారి 'ఎప్పుడు మూలకం' 5 ” పునరావృతం సమయంలో శ్రేణిలో సంభవిస్తుంది:
అమరిక. ప్రతి ( మూలకం => {
ఉంటే ( మూలకం == 5 ) {
బయటకి దారి ;
}
} ) ;
ఇది లోపానికి కూడా కారణమవుతుంది:
forEach() లూప్‌ను ఆపడం అసాధ్యమైన సవాలుగా కనిపిస్తోంది, అయితే ఇక్కడ మూల్యాంకనం చేయడానికి కొన్ని పరిష్కారాలు ఉన్నాయి:
విధానం 1: “ప్రయత్నించండి/క్యాచ్” బ్లాక్‌ని ఉపయోగించి ప్రతి ఒక్కరికీ జావాస్క్రిప్ట్‌ను ఆపండి
JavaScriptలో forEach() లూప్‌ను ఆపడానికి లేదా విచ్ఛిన్నం చేయడానికి అంతర్నిర్మిత మార్గం లేదు. అయితే, మీరు మినహాయింపును విసిరి, లూప్‌లో పట్టుకోవడం ద్వారా ఇలాంటి ప్రభావాన్ని సాధించవచ్చు. దీన్ని చేయడానికి, 'ని ఉపయోగించండి ప్రయత్నించండి/పట్టుకోండి ”బ్లాక్. ఇది కోడ్‌లో సంభవించే మినహాయింపులు లేదా రన్‌టైమ్ ఎర్రర్‌లను నిర్వహించడానికి మిమ్మల్ని అనుమతించే నియంత్రణ నిర్మాణం. మినహాయింపుకు కారణమయ్యే కోడ్ ' ప్రయత్నించండి ”బ్లాక్, అయితే మినహాయింపును నిర్వహించే కోడ్ “లో ఉంటుంది క్యాచ్ ”బ్లాక్.
వాక్యనిర్మాణం
ప్రయత్నించండి/క్యాచ్ బ్లాక్‌ని ఉపయోగించడం కోసం దిగువ ఇవ్వబడిన సింటాక్స్‌ని ఉపయోగించండి:
ప్రయత్నించండి {// కోడ్ మినహాయింపును ఇవ్వవచ్చు
} క్యాచ్ ( లోపం ) {
మినహాయింపును నిర్వహించడానికి // కోడ్
}
ఉదాహరణ
లోపాన్ని నిర్వహించడం ద్వారా లూప్‌ను ఆపడానికి forEach() లూప్ కోడ్‌ను ట్రై/క్యాచ్ బ్లాక్‌లో చుట్టండి:
ప్రయత్నించండి {అమరిక. ప్రతి ( మూలకం => {
ఉంటే ( మూలకం == 5 ) {
త్రో కొత్త మినహాయింపు ( 'ఆపు' ) ;
}
} ) ;
} క్యాచ్ ( మరియు ) {
కన్సోల్. లాగ్ ( 'లూప్ ముగిసింది' ) ;
}
పై కోడ్ స్నిప్పెట్‌లో, ట్రై బ్లాక్‌లో మినహాయింపు విసిరినప్పుడు, ప్రోగ్రామ్ వెంటనే క్యాచ్ బ్లాక్‌కి వెళ్లి అక్కడ కోడ్‌ని అమలు చేస్తుంది. ఇది మాకు మినహాయింపును నిర్వహించగల సామర్థ్యాన్ని అందిస్తుంది మరియు ప్రోగ్రామ్ క్రాష్ కాకుండా కాపాడుతుంది.
అవుట్‌పుట్
జావాస్క్రిప్ట్‌లో forEach() లూప్‌ను ఆపడానికి ట్రై/క్యాచ్ బ్లాక్‌ని ఉపయోగించడం సాధారణంగా సిఫార్సు చేయబడదు. ఎందుకంటే ట్రై/క్యాచ్ బ్లాక్ యొక్క ఉద్దేశ్యం లూప్ యొక్క ప్రవాహాన్ని నియంత్రించడం కంటే మినహాయింపులను నిర్వహించడం. కాబట్టి, ప్రత్యామ్నాయ పద్ధతులను ఉపయోగించడం మంచిది.
విధానం 2: జావాస్క్రిప్ట్‌లో “ఫర్” లూప్‌ని ఉపయోగించండి
ఉపయోగించడానికి ' కోసం forEach() లూప్‌కు బదులుగా ”లూప్. బ్రేక్ స్టేట్‌మెంట్ ఫర్ లూప్‌లో ఉపయోగించబడుతుంది, లూప్ టెర్మినేషన్ కండిషన్ చేరుకోవడానికి ముందే ముందస్తు నిష్క్రమణను అనుమతిస్తుంది. మీరు ఒక నిర్దిష్ట పరిస్థితిని మూల్యాంకనం చేసినప్పుడు ' నిజం ” లేదా ఏదైనా ఇతర కారణాల వల్ల లూప్ నుండి నిష్క్రమించండి.
వాక్యనిర్మాణం
“ని ఉపయోగించడానికి క్రింది వాక్యనిర్మాణాన్ని అనుసరించండి కోసం ”లూప్:
కోసం ( నేను అనుమతించు = 0 ; i < అమరిక. పొడవు ; i ++ ) {//పరిస్థితి
బ్రేక్ ;
}
ఉదాహరణ
ఉపయోగించడానికి ' కోసం లూప్ దాని పొడవు వరకు శ్రేణిని మళ్ళిస్తుంది మరియు మూలకం సంభవించినప్పుడు శ్రేణిని ఆపండి' 5 ఒక శ్రేణిలో:
కోసం ( నేను అనుమతించు = 0 ; i < అమరిక. పొడవు ; i ++ ) {స్థిరంగా మూలకం = అమరిక [ i ] ;
ఉంటే ( మూలకం == 5 ) {
బ్రేక్
}
కన్సోల్. లాగ్ ( మూలకం ) ;
}
'' అయినప్పుడు లూప్ ఆగిపోతుంది 5 శ్రేణిలో కనిపిస్తుంది:
విధానం 3: జావాస్క్రిప్ట్‌లో “ఫర్-ఆఫ్” లూప్‌ని ఉపయోగించండి
మీరు కూడా ఉపయోగించవచ్చు ' కోసం forEach() లూప్‌కు ప్రత్యామ్నాయంగా లూప్. ఇది శ్రేణి లేదా స్ట్రింగ్ వంటి పునరావృత వస్తువు యొక్క మూలకాల ద్వారా లూప్ చేయడానికి ఉపయోగించబడుతుంది. ఇది ఫర్-ఇన్ లూప్ మాదిరిగానే ఉంటుంది కానీ ప్రత్యేకంగా మళ్ళించదగిన వస్తువులతో పని చేయడానికి రూపొందించబడింది మరియు సాధారణంగా మరింత సంక్షిప్తంగా మరియు సులభంగా చదవడానికి పరిగణించబడుతుంది.
వాక్యనిర్మాణం
క్రింది సింటాక్స్ లూప్ కోసం ఉపయోగించబడుతుంది:
కోసం ( స్థిరంగా శ్రేణి యొక్క మూలకం ) {//పరిస్థితి
బ్రేక్ ;
}
ఉదాహరణ
శ్రేణిని మళ్ళించడానికి మరియు మూలకం ' అయినప్పుడు పునరావృతాన్ని ఆపడానికి ఇక్కడ for-of loop ఉపయోగించబడుతుంది 5 ” పునరావృతం సమయంలో శ్రేణిలో కనిపిస్తుంది:
కోసం ( స్థిరంగా శ్రేణి యొక్క మూలకం ) {ఉంటే ( మూలకం == 5 ) {
బ్రేక్ ;
}
కన్సోల్. లాగ్ ( మూలకం ) ;
}
అవుట్‌పుట్
జావాస్క్రిప్ట్‌లో forEach() లూప్‌ని ఆపడం అంతే.
ముగింపు
JavaScriptలో forEach() లూప్‌ను ఆపడానికి లేదా విచ్ఛిన్నం చేయడానికి అంతర్నిర్మిత మార్గం లేదు. కానీ మీరు '' ఉపయోగించి ఇలాంటి ప్రభావాన్ని సాధించవచ్చు ప్రయత్నించండి/పట్టుకోండి' నిరోధించు. అయినప్పటికీ, లూప్ యొక్క ప్రవాహాన్ని నియంత్రించడానికి బదులుగా మినహాయింపులను నిర్వహించడానికి ప్రయత్నించండి/క్యాచ్ బ్లాక్ అయినందున దీనిని ఉపయోగించడం సిఫార్సు చేయబడలేదు. కాబట్టి, ప్రత్యామ్నాయ పద్ధతులను ఉపయోగించడం ఆదర్శవంతమైన విధానం, ఉదాహరణకు ' కోసం ' లేదా ' కోసం ” లూప్. ఈ ఆర్టికల్‌లో, జావాస్క్రిప్ట్‌లో forEach() లూప్‌ను ఆపే విధానాన్ని మేము వివరించాము.