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