ఈ వ్యాసం JavaScriptలో ఏదైనా పునరావృతం కావడానికి వివిధ పద్ధతులను చర్చిస్తుంది.
జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయడం ఎలా?
క్రింది మార్గాల్లో జావాస్క్రిప్ట్‌లో స్ట్రింగ్ పునరావృతం చేయవచ్చు:
- అయితే లూప్ పద్ధతిని ఉపయోగించడం
- ES6 రిపీట్() పద్ధతిని ఉపయోగించడం
- రికర్షన్ ఉపయోగించి
- ఫిల్ () పద్ధతిని ఉపయోగించడం
ప్రతి పద్ధతిని వివరంగా పరిశీలిద్దాం.
విధానం 1: వైల్ లూప్‌ని ఉపయోగించి జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయండి
' కాగా ” అనేది జావాస్క్రిప్ట్‌లోని కంట్రోల్ ఫ్లో స్టేట్‌మెంట్, ఇది పేర్కొన్న షరతులో పదేపదే అమలు చేయబడుతుంది. ప్రతి పునరావృతానికి ముందు పరిస్థితి పరిశీలించబడుతుంది. కండిషన్ ఖచ్చితమైన వరకు అయితే లూప్ నడుస్తుంది. షరతు తప్పు అయిన తర్వాత, లూప్ అమలు చేయడం ఆగిపోతుంది. కింది కోడ్ అయితే లూప్‌లను ఉపయోగించి జావాస్క్రిప్ట్‌లో పునరావృత ప్రక్రియను వివరిస్తుంది:
DOCTYPE html >
< html >
< స్క్రిప్ట్ >
ఫంక్షన్ పునరావృతం ( str, కౌంట్ ) {
rpt_Strని అనుమతించండి = '' ;
అయితే ( లెక్కించండి > 0 ) {
rpt_Str += str ;
లెక్కించండి --;
}
తిరిగి rpt_Str ;
}
పత్రం. వ్రాయడానికి ( పునరావృతం ( 'టేలర్' , 6 ) ) ;
స్క్రిప్ట్ >
html >
పై ఉదాహరణలో:
- ఒక ఫంక్షన్ రిపీట్() స్క్రిప్ట్ ట్యాగ్ లోపల “str” మరియు “కౌంట్” పారామీటర్‌లతో నిర్వచించబడింది.
- తరువాత, మేము ఖాళీ స్ట్రింగ్ “rpt_str”ని నిర్వచించాము మరియు కౌంట్ 0 కంటే ఎక్కువగా ఉండాలనే షరతుతో కాసేపు లూప్‌ని ప్రారంభించాము.
- “rpt_str” “str” విలువను కలిగి ఉంటుంది మరియు షరతు ఇకపై నిజం కానట్లయితే అయితే లూప్ పనిచేస్తుంది. ఈ సందర్భంలో, గణన విలువ 6 కాబట్టి స్ట్రింగ్ 6 సార్లు ముద్రించబడుతుంది.
అవుట్‌పుట్
'TAYLOR' స్ట్రింగ్ 6 సార్లు పునరావృతమవుతుంది, ఇది గణనకు సమానం:
విధానం 2: ES6 రిపీట్()ని ఉపయోగించి జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయండి
ES6 పునరావృతం () జావాస్క్రిప్ట్‌లో స్ట్రింగ్‌ను పునరావృతం చేయడానికి ఉపయోగించవచ్చు. కాల్ చేసినప్పుడు నిర్దిష్ట నకిలీలను కలిగి ఉన్న స్ట్రింగ్ తిరిగి ఇవ్వబడుతుంది. రిపీట్():
DOCTYPE html >< html >
< స్క్రిప్ట్ >
ఫంక్షన్ rpt_str ( str,కౌంట్ ) {
ఉంటే ( లెక్కించండి > 0 )
తిరిగి str. పునరావృతం ( లెక్కించండి ) ;
లేకపోతే
తిరిగి '' ;
}
పత్రం. వ్రాయడానికి ( rpt_str ( 'జావాస్క్రిప్ట్' , 5 ) ) ;
స్క్రిప్ట్ >
html >
పై కోడ్‌లో,
- ఒక ఫంక్షన్ “rpt_str()” పారామితులు str మరియు కౌంట్‌తో నిర్వచించబడింది.
- str విలువ 'జావాస్క్రిప్ట్'గా కేటాయించబడింది, ఇది లెక్కించడానికి కేటాయించిన విలువ ప్రకారం పునరావృతమవుతుంది.
అవుట్‌పుట్
ఈ ఉదాహరణలో, లెక్కించడానికి కేటాయించిన విలువ 5 కాబట్టి రిపీట్() ఫంక్షన్ JavaScriptని 5 సార్లు పునరావృతం చేస్తుంది:
విధానం 3: రికర్షన్‌ని ఉపయోగించి జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయండి
రికర్షన్ ఒక ఫంక్షన్‌కు కావలసిన ఫలితాన్ని పొందే వరకు దానినే పదే పదే కాల్ చేయడానికి అనుమతిస్తుంది. రికర్షన్‌లో, రికర్షన్‌ను ముగించడానికి ప్రాథమిక/బేస్ కేస్ తప్పనిసరిగా పేర్కొనబడాలి. ఇది సాంప్రదాయకంగా షరతులతో కూడిన నిబంధనలో ఉంది. మనం కోరుకున్న ఫలితాన్ని పొందే వరకు పునరావృత ఫంక్షన్ పునరావృతంగా కాల్ చేయడం ద్వారా పనిచేస్తుంది. జావాస్క్రిప్ట్‌లో పునరావృతం చేయడానికి రికర్షన్ పద్ధతిని అర్థం చేసుకోవడానికి క్రింది ఉదాహరణ సహాయపడుతుంది:
! DOCTYPE html >< html >
< స్క్రిప్ట్ >
ఫంక్షన్ rpt_str ( str,కౌంట్ ) {
ఉంటే ( లెక్కించండి < 0 )
తిరిగి '' ;
ఉంటే ( లెక్కించండి === 1 )
తిరిగి str ;
లేకపోతే
తిరిగి str + rpt_str ( str, కౌంట్ - 1 ) ;
}
పత్రం. వ్రాయడానికి ( rpt_str ( 'కోడ్' , 7 ) ) ;
స్క్రిప్ట్ >
html >
పై కోడ్‌లో:
- “rpt_str()” ఫంక్షన్ “str” మరియు “కౌంట్” పారామితులతో నిర్వచించబడింది.
- గణన విలువ 0 కంటే తక్కువగా ఉంటే, ఖాళీ స్ట్రింగ్ తిరిగి ఇవ్వబడుతుంది. గణన విలువ 1 అయితే, అది strని అందిస్తుంది మరియు str విలువ 1 కంటే ఎక్కువగా ఉంటే, ఫంక్షన్ str యొక్క ఇన్‌పుట్ విలువను rpt_str(str, కౌంట్ – 1) ఫలితంతో సంగ్రహిస్తుంది.
- ఇక్కడ, str విలువ “CODE” మరియు గణన విలువ 7 కాబట్టి పునరావృతమయ్యే స్ట్రింగ్ కోడ్‌ను 7 సార్లు ముద్రిస్తుంది.
అవుట్‌పుట్:
విధానం 4: పూరకం() ఫంక్షన్‌ని ఉపయోగించి జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయండి
JavaScript అందిస్తుంది a పూరించండి () స్టాటిక్ విలువలతో శ్రేణిని పూరించడానికి మమ్మల్ని అనుమతించే పద్ధతి. జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయడానికి ఇది join() ఫంక్షన్‌తో ఉపయోగించవచ్చు. ఉదాహరణకు, స్ట్రింగ్ విలువలను ఫిల్() ఫంక్షన్‌ని ఉపయోగించి ఖాళీ శ్రేణిలో చొప్పించవచ్చు మరియు రిపీట్ స్ట్రింగ్‌ను పొందడానికి జాయిన్() ఫంక్షన్‌తో కలిసి కలపవచ్చు. మీరు ఫిల్() ఫంక్షన్‌తో స్ట్రింగ్‌ను ఎలా పునరావృతం చేయవచ్చో చూపే కోడ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది:
< html >< శరీరం >
< స్క్రిప్ట్ >
str వీలు = 'ముందు'
rpt_strని అనుమతించండి = అమరిక ( 5 ) . నింపండి ( str ) . చేరండి ( '' )
పత్రం. వ్రాయడానికి ( rpt_str ) ;
స్క్రిప్ట్ >
శరీరం >
html >
పై ఉదాహరణలో:
- ఒక వేరియబుల్ str నిర్వచించబడింది మరియు “ ఫ్రంట్END ” విలువతో కేటాయించబడుతుంది.
- ఫంక్షన్ అర్రే(5) 5 స్లాట్‌లను సృష్టిస్తుంది, దీనిలో స్ట్రింగ్ నిండి ఉంటుంది మరియు మళ్లీ మళ్లీ స్ట్రింగ్‌ను ఏర్పరుస్తుంది. విలువ “rpt_str” వేరియబుల్‌లో నిల్వ చేయబడుతుంది.
- document.write(rpt_str) పునరావృతమయ్యే స్ట్రింగ్‌ను ప్రింట్ చేస్తుంది.
అవుట్‌పుట్
కోడ్‌ని రన్ చేస్తున్నప్పుడు, 'FRONTEND' స్ట్రింగ్ 5 సార్లు పునరావృతమవుతుంది:
విభిన్న పద్ధతులను ఉపయోగించి జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయడం గురించి అంతే.
ముగింపు
జావాస్క్రిప్ట్‌లో ఏదైనా పునరావృతం చేయడానికి ఒక సాధారణ పద్ధతి ES6 రిపీట్() ఫంక్షన్‌ని ఉపయోగిస్తుంది, ఇది మూలకం యొక్క పునరావృతాల సంఖ్యను సూచించే నిర్దిష్ట పరామితిని తీసుకుంటుంది. కాసేపు లూప్, రికర్సివ్ ఫంక్షన్‌లు లేదా ఫిల్() పద్ధతిని ఉపయోగించడం వంటి ఇతర పద్ధతులు. ఈ కథనం జావాస్క్రిప్ట్‌లో వాటి ఉదాహరణలతో పాటుగా పునరావృతమయ్యే వివిధ మార్గాలను వివరిస్తుంది.