.
ఈ వ్రాత జావాస్క్రిప్ట్‌లో “console.time()” పద్ధతి యొక్క పని మరియు వినియోగాన్ని వివరిస్తుంది.
జావాస్క్రిప్ట్‌లో “console.time()” మెథడ్ ఏమి చేస్తుంది?
ది ' console.time() ”పద్ధతి ఆపరేషన్ లేదా ఫంక్షన్ యొక్క అమలు సమయాన్ని ట్రాక్ చేస్తుంది. ఇది పేర్కొన్న జావాస్క్రిప్ట్ ఆపరేషన్ వ్యవధిని గణించే టైమర్‌ను ప్రారంభిస్తుంది మరియు 'ని ఉపయోగించి ముగుస్తుంది console.timeEnd() ” పద్ధతి.
వాక్యనిర్మాణం
కన్సోల్. సమయం ( లేబుల్ )
“console.time()” ఐచ్ఛిక “కి మద్దతు ఇస్తుంది లేబుల్ ” ఆపరేషన్ పేరును నిర్దేశించే వాదన. ప్రతి ఆపరేషన్‌ని సులభంగా గుర్తించడం కోసం “console.time()” పద్ధతి యొక్క బహుళ సంఘటనలలో ఇది సిఫార్సు చేయబడింది.
HTML కోడ్
కింది HTML కోడ్ ద్వారా వెళ్ళండి:
< h2 > కన్సోల్. సమయం ( ) పద్ధతి జావాస్క్రిప్ట్‌లో h2 >< p > కన్సోల్‌ని తెరవండి ( F12 ) అమలును తనిఖీ చేయడానికి సమయం p >
పై కోడ్ స్నిప్పెట్‌లో:
- ది ' ” ట్యాగ్ పేర్కొన్న స్టేట్‌మెంట్‌ను ప్రదర్శించే ఉపశీర్షికను సృష్టిస్తుంది.
- ది ' ” ట్యాగ్ పేరాను నిర్దేశిస్తుంది.
గమనిక: పై HTML కోడ్ కథనం అంతటా అనుసరించబడుతుంది.
ఉదాహరణ 1: కోడ్ ఫంక్షనాలిటీ ('కోసం' లూప్) యొక్క అమలు సమయాన్ని విశ్లేషించడానికి “console.time()” పద్ధతిని వర్తింపజేయడం
ఈ ఉదాహరణలో, ' console.time() 'నిర్వచించిన అమలు సమయాన్ని పొందడానికి పద్ధతి ఉపయోగించబడుతుంది' కోసం ” జావాస్క్రిప్ట్‌లో లూప్.
జావాస్క్రిప్ట్ కోడ్
కోడ్ యొక్క దిగువ పేర్కొన్న పంక్తులను పరిగణించండి:
< స్క్రిప్ట్ >కన్సోల్. సమయం ( 'లూప్ కోసం' ) ;
కోసం ( అక్కడ ఒక = 0 ; a < 1000 ; a ++ ) {
}
కన్సోల్. సమయం ముగింపు ( 'లూప్ కోసం' ) ;
స్క్రిప్ట్ >
పై కోడ్ బ్లాక్‌లో:
- పేర్కొనండి ' console.time() 'లేబుల్ ఉన్న పద్ధతి' లూప్ కోసం ” నిర్వచించబడిన “కోసం” లూప్ ప్రారంభంలో.
- ఆ తర్వాత ఒక ' కోసం ”లూప్ ప్రారంభించబడింది, అది 1000 సార్లు పునరావృతమవుతుంది.
- చివరగా, ' console.timeEnd() ” పద్ధతి నిర్వచించబడింది, ఇది టైమర్‌ను ఆపివేస్తుంది మరియు “ఫర్” లూప్ యొక్క మొత్తం రన్ సమయాన్ని చూపుతుంది.
అవుట్‌పుట్
చూసినట్లుగా, కన్సోల్ 'ఫర్' లూప్ యొక్క మొత్తం అమలు సమయాన్ని మిల్లీసెకన్లలో (ms) చూపుతుంది.
ఉదాహరణ 2: లూప్‌ల అమలు సమయాన్ని సరిపోల్చడానికి “console.timeEnd()” పద్ధతిని వర్తింపజేయడం
ఈ ఉదాహరణ ఎలా వివరిస్తుంది ' console.time() 'పద్ధతి బహుళ కార్యకలాపాలను సరిపోల్చడానికి ఉపయోగించబడుతుంది, అనగా, 'లూప్స్' అమలు సమయం పోలిక కోసం.
జావాస్క్రిప్ట్ కోడ్
కింది జావాస్క్రిప్ట్ కోడ్ యొక్క అవలోకనం:
< స్క్రిప్ట్ >కన్సోల్. సమయం ( 'లూప్ కోసం మొదటిది' ) ;
కోసం ( లో ఉన్నాడు = 0 ; i < 1000 ; i ++ ) {
}
కన్సోల్. సమయం ముగింపు ( 'లూప్ కోసం మొదటిది' ) ;
కన్సోల్. సమయం ( 'లూప్ కోసం రెండవది' ) ;
కోసం ( అక్కడ ఒక = 0 ; a < 2000 ; a ++ ) {
}
కన్సోల్. సమయం ముగింపు ( 'లూప్ కోసం రెండవది' ) ;
స్క్రిప్ట్ >
పై కోడ్‌లో:
- ముందుగా, 'ని పేర్కొనండి console.time() 'మొదట ప్రారంభించబడిన టైమర్‌ను ప్రారంభించే పద్ధతి' కోసం ” లూప్.
- తదుపరి దశలో, మొదటి 'కోసం' లూప్ ప్రారంభించబడింది.
- ఆ తర్వాత, 'అటాచ్ చేయండి console.timeEnd() ”మొత్తం అమలు సమయాన్ని పొందడం కోసం టైమర్‌ను ఆపడానికి పద్ధతి.
- తరువాత, 'console.time()' పద్ధతి తరువాతి లూప్ కోసం మళ్లీ వర్తించబడుతుంది మరియు 'console.timeEnd()' పద్ధతి కూడా టైమర్‌ను ఆపివేస్తుంది.
అవుట్‌పుట్
విశ్లేషించబడినట్లుగా, కన్సోల్ ప్రారంభించబడిన “ఫర్” లూప్‌ల యొక్క మొత్తం రన్ టైమ్‌ను చూపుతుంది, తద్వారా వాటిని పోల్చడం.
ముగింపు
జావాస్క్రిప్ట్ అంతర్నిర్మిత “ని అందిస్తుంది console.time() ” టైమర్‌ను ప్రారంభించి, పేర్కొన్న కోడ్ కార్యాచరణ వ్యవధిని గణించే పద్ధతి. ఇది ఆపరేషన్ల అమలు సమయాన్ని మరియు పరీక్ష ప్రయోజనాల కోసం సరిపోల్చడంలో సహాయపడుతుంది. టైమర్ ప్రారంభమైన తర్వాత, అది “console.timeEnd()” పద్ధతి సహాయంతో ఆగిపోతుంది.
ఈ గైడ్ జావాస్క్రిప్ట్‌లో “console.time()” పద్ధతి యొక్క పని మరియు వినియోగాన్ని వివరించింది.