పునరావృత విధులు అనేది మరొక పద్ధతిలో ఒక పద్ధతిని పిలిచే విధులు. అయినప్పటికీ, అనంతమైన పునరావృతం స్టాక్ సైజు లోపానికి కారణమవుతుంది. అనేక అభ్యర్థనలు పెండింగ్‌లో ఉన్నందున స్టాక్ సైజ్ ఎర్రర్ ఏర్పడింది. ఫంక్షన్‌కు కాల్ చేస్తున్నప్పుడు ఈ సమస్య తలెత్తుతుంది. దీనిని పరిగణనలోకి తీసుకోవడం ద్వారా, గరిష్ట కాల్ స్టాక్ పరిమాణం జావాస్క్రిప్ట్‌లోని లోపాన్ని మించిపోయిందని ఈ కథనం వివరిస్తుంది. అంతేకాకుండా, లోపాన్ని పరిష్కరించడానికి పరిష్కారం కూడా అందించబడుతుంది.
వ్యాసం మాకు ఈ క్రింది విధంగా ఉపయోగపడుతుంది:
- జావాస్క్రిప్ట్‌లో గరిష్ట కాల్ స్టాక్ పరిమాణం మించిపోయింది
- గరిష్ట కాల్ స్టాక్ పరిమాణాన్ని పరిష్కరించడానికి కండిషన్ ఉంటే ఉపయోగించడం లోపం మించిపోయింది
- గరిష్ట కాల్ స్టాక్ పరిమాణాన్ని పరిష్కరించడానికి లూప్ కోసం ఉపయోగించడం వలన లోపం ఏర్పడింది.
జావాస్క్రిప్ట్‌లో గరిష్ట కాల్ స్టాక్ పరిమాణం మించిపోయింది
వినియోగదారు పునరావృత ఫంక్షన్‌కు కాల్ చేసినప్పుడు స్టాక్ పరిమాణం మించిన లోపం ఏర్పడుతుంది. ఒక పద్ధతిని పదేపదే ప్రారంభించడం వల్ల ఈ రకమైన లోపం సంభవిస్తుంది. ది fun_user() ఫంక్షన్ లోపల రికర్సివ్ కాల్‌గా ఉపయోగించబడుతుంది fun_user() కన్సోల్ విండోలో లోపాన్ని సృష్టించడానికి జావాస్క్రిప్ట్‌లో.
కోడ్
console.log ( 'గరిష్ట కాల్ స్టాక్ పరిమాణం మించిపోయింది' ) ;
ఫన్_యూజర్ ( ) ;
ఫంక్షన్ ఫన్_యూజర్ ( )
{
ఫన్_యూజర్ ( ) ;
}
ఈ కోడ్‌లో, ది 'గరిష్ట కాల్ స్టాక్ పరిమాణం లోపం మించిపోయింది' ఒక పద్ధతిని కాల్ చేయడం ద్వారా ఉత్పత్తి చేయబడుతుంది “fun_user()” ఫంక్షన్ లోపల.
కోడ్ లోపాన్ని ఇలా ప్రదర్శిస్తుంది 'RangeError: గరిష్ట కాల్ స్టాక్ పరిమాణం మించిపోయింది.'
ఈ లోపాన్ని పరిష్కరించడానికి అనేక మార్గాలు ఉన్నాయి లూప్ కోసం మరియు షరతులతో కూడిన ప్రకటనలు , ఇది ఫంక్షన్ కాల్‌ని పరిమితం చేయడానికి ఉపయోగించవచ్చు.
పరిష్కారం 1: గరిష్ట కాల్ స్టాక్ పరిమాణాన్ని పరిష్కరించడానికి కండిషన్ ఉంటే ఉపయోగించడం లోపం మించిపోయింది
లోపాన్ని పరిష్కరించడానికి, జావాస్క్రిప్ట్‌లో స్టాక్ పరిమాణాన్ని పరిమితం చేయడానికి if షరతు వర్తించబడుతుంది. ఉదాహరణకు, కోడ్ క్రింద ఇవ్వబడింది.
కోడ్
ఉంది i = 1 ;ఫన్_యూజర్ ( i ) ;
ఫంక్షన్ ఫన్_యూజర్ ( i ) {
ఉంటే ( i < = 10 )
{
console.log ( 'జావాస్క్రిప్ట్‌కు స్వాగతం' ) ;
i = i+ 1 ;
ఫన్_యూజర్ ( i ) ;
} }
కోడ్ యొక్క వివరణ క్రింది విధంగా ఉంది:
- మొదట, ఒక వేరియబుల్ 'నేను' విలువ 1తో ప్రారంభించబడింది.
- దాని తరువాత, fun_user() వేరియబుల్‌ను పాస్ చేయడం ద్వారా పద్ధతి ఉపయోగించబడుతుంది 'నేను'.
- ఈ ఫంక్షన్‌లో, పునరావృతాన్ని పరిమితం చేసే షరతు వర్తింపజేస్తే 10 .
- చివరగా, సందేశం “జావాస్క్రిప్ట్‌కు స్వాగతం” ఉపయోగించి ప్రదర్శించబడుతుంది “console.log()” పద్ధతి.
అవుట్పుట్
పరిష్కారం 2: గరిష్ట కాల్ స్టాక్ పరిమాణాన్ని అధిగమించిన లోపాన్ని పరిష్కరించడానికి లూప్ కోసం ఉపయోగించడం
లోపాన్ని పరిష్కరించడానికి, జావాస్క్రిప్ట్‌లో పునరావృతాలను పరిమితం చేయడానికి లూప్ కోసం ఉపయోగించబడుతుంది. ఉదాహరణకు, కోడ్ క్రింద ఇవ్వబడింది.
కోడ్
వీలు output = 0 ;కోసం ( వీలు నేను = 5 ; i > 0 ; నేను-- )
{
అవుట్పుట్ += జోడించు ( 1 , 1 ) ;
}
ఫంక్షన్ జోడించు ( ఎ, బి ) {
తిరిగి a + b;
}
console.log ( అవుట్పుట్ ) ;
ఈ కోడ్‌లో:
- వేరియబుల్ 'అవుట్పుట్' 0 విలువతో ప్రారంభించబడింది.
- ఆ తర్వాత, ఐదు పునరావృత్తులు చేయడానికి a for loop ఉపయోగించబడుతుంది. ఈ లూప్‌లో, ది జోడించు() విలువ 1ని పాస్ చేయడం ద్వారా పద్ధతి అంటారు.
- పద్దతి జోడించు() రెండు వేరియబుల్స్ యొక్క జోడింపును అందిస్తుంది a మరియు బి .
- చివరికి, ది లాగ్ () కన్సోల్ విండోలో అవుట్‌పుట్‌ను ప్రదర్శించడానికి పద్ధతి ఉపయోగించబడుతుంది.
అవుట్పుట్
అవుట్పుట్ తిరిగి వస్తుంది '10' JavaScriptలో గరిష్ట కాల్ స్టాక్ పరిమాణం యొక్క లోపాన్ని పరిష్కరించడం ద్వారా.
ముగింపు
పునరావృత ఫంక్షన్ల అనంతమైన కాలింగ్ ఇలా జరుగుతుంది 'గరిష్ట కాల్ స్టాక్ పరిమాణం లోపం మించిపోయింది' జావాస్క్రిప్ట్‌లో. ఈ రకమైన లోపాన్ని కలిగించడానికి గల కారణాలను ఈ వ్యాసం వివరిస్తుంది. తరువాత, సహా రెండు పరిష్కారాలు 'లూప్ కోసం' మరియు 'షరతులతో కూడిన ప్రకటనలు' లోపాన్ని పరిష్కరించడానికి ఉపయోగించబడతాయి. అందువల్ల, ఈ పరిష్కారాలను ఉపయోగించడం ద్వారా కాలింగ్ ఫంక్షన్‌లు పరిమితం చేయబడ్డాయి.