అర్రే ఆబ్జెక్ట్ మూలకాల సేకరణను సూచిస్తుంది. ఇది బహుళ వేరియబుల్స్ యొక్క గందరగోళాన్ని నివారించడానికి, తద్వారా వాటిని క్రమబద్ధీకరించడానికి పెద్ద మొత్తంలో డేటాను నిర్వహించడంలో సహాయపడుతుంది. వినియోగదారు అర్రే ఆబ్జెక్ట్‌కు ఏదైనా అదనపు పద్ధతి మరియు ప్రాపర్టీని వర్తింపజేయాలనుకుంటే, అది ప్రతి మూలకానికి ఒక్కొక్కటిగా ఆ కొత్త ప్రాపర్టీ/పద్ధతిని వర్తింపజేయాల్సిన అవసరం లేదు. బదులుగా, ఇది జావాస్క్రిప్ట్ అర్రేని ఉపయోగించడం ద్వారా సమర్థవంతంగా చేయవచ్చు ' నమూనా ”నిర్మాణకర్త. ఈ కన్స్ట్రక్టర్ కావలసిన అర్రే ఆబ్జెక్ట్‌కు కొత్త పద్ధతులు మరియు లక్షణాలను వర్తింపజేయడంలో సహాయపడుతుంది.
ఈ గైడ్ జావాస్క్రిప్ట్‌లో అర్రే “ప్రోటోటైప్” కన్స్ట్రక్టర్ వినియోగాన్ని వివరిస్తుంది.
జావాస్క్రిప్ట్‌లో అర్రే “ప్రోటోటైప్” కన్స్ట్రక్టర్ను ఎలా ఉపయోగించాలి?
అర్రే ' నమూనా జావాస్క్రిప్ట్ ఫంక్షన్ సహాయంతో అర్రే ఆబ్జెక్ట్‌కు కొత్త పద్ధతులు మరియు లక్షణాలను జోడించడానికి కన్స్ట్రక్టర్ ఉపయోగించబడుతుంది. ఇది డిఫాల్ట్‌గా దాని పేరు మరియు విలువ వలె అన్ని శ్రేణి విలువలకు నిర్మిత ఆస్తిని వర్తింపజేస్తుంది.
వాక్యనిర్మాణం
Array.prototype.name = విలువ
పై వాక్యనిర్మాణంలో, “ పేరు ” దానితో కొత్తగా జోడించిన ఆస్తిని నిర్దేశిస్తుంది విలువ ”అది మొత్తం అర్రే వస్తువుకు వర్తిస్తుంది.
పైన నిర్వచించబడిన ఆస్తిని దాని వాక్యనిర్మాణం సహాయంతో ఆచరణాత్మకంగా ఉపయోగించుకుందాం.
HTML కోడ్
ముందుగా, పేర్కొన్న HTML కోడ్‌ను చూడండి:
< p > ది 'ప్రోటోటైప్' కన్స్ట్రక్టర్ సహాయం చేస్తుంది లో కొత్త పద్ధతుల జోడింపు / ఇచ్చిన శ్రేణికి లక్షణాలు ( ) వస్తువు. p >< బటన్ క్లిక్ చేయండి = 'jsFunc()' > ప్రతి స్ట్రింగ్ పొడవును పొందండి బటన్ >
< p id = 'నమూనా' > p >
< p id = 'కోసం' > p >
పై కోడ్ లైన్లలో:
- ది ' ” ట్యాగ్ పేరా స్టేట్‌మెంట్‌ను నిర్దేశిస్తుంది.
- ది ' <బటన్> ”ట్యాగ్ బటన్ క్లిక్‌పై పేర్కొన్న ఫంక్షన్ “jsFunc()”ని అమలు చేయడానికి “onclick” ఈవెంట్‌తో బటన్‌ను పొందుపరుస్తుంది.
- చివరి రెండు ' ”ట్యాగ్‌లు వరుసగా వాటికి కేటాయించిన “నమూనా” మరియు “పారా”తో ఖాళీ పేరాగ్రాఫ్‌లను జోడిస్తాయి.
గమనిక: ఈ గైడ్‌లో ఇచ్చిన అన్ని ఉదాహరణలలో ఈ HTML కోడ్ అనుసరించబడింది.
ఉదాహరణ 1: కొత్త పద్ధతిని జోడించడం ద్వారా అర్రే ఆబ్జెక్ట్ పొడవును లెక్కించడానికి “ప్రోటోటైప్” కన్‌స్ట్రక్టర్‌ని వర్తింపజేయడం
ఈ ఉదాహరణ కొత్తగా జోడించిన పద్ధతి సహాయంతో అర్రే ఆబ్జెక్ట్‌లోని ప్రతి స్ట్రింగ్ యొక్క పొడవును లెక్కించడానికి “ప్రోటోటైప్” కన్స్ట్రక్టర్ను ఉపయోగిస్తుంది.
జావాస్క్రిప్ట్ కోడ్
ఇచ్చిన జావాస్క్రిప్ట్ కోడ్‌ని అనుసరించండి:
< స్క్రిప్ట్ >Array.prototype.stringLength = ఫంక్షన్ ( ) {
కోసం ( ఎక్కడ t = 0 ; t < ఈ.పొడవు; t++ ) {
ఇది [ t ] = ఇది [ t ] .పొడవు;
}
} ;
ఫంక్షన్ jsFunc ( ) {
var str = [ 'HTML' , 'CSS' , 'జావాస్క్రిప్ట్' ] ;
document.getElementById ( 'నమూనా' ) .innerHTML = str;
str.stringLength ( ) ;
document.getElementById ( 'కోసం' ) .innerHTML = str;
}
స్క్రిప్ట్ >
పై కోడ్ లైన్లలో:
- అర్రే యొక్క ప్రాథమిక వాక్యనిర్మాణాన్ని వర్తింపజేయి ' నమూనా 'కొత్త పద్ధతిని జోడించే కన్స్ట్రక్టర్' స్ట్రింగ్ పొడవు ”ఒక విధిని నిర్వచించడం.
- తరువాత, ఫంక్షన్ నిర్వచనంలో, ' కోసం 'పొడవు' లక్షణాన్ని ఉపయోగించి వాటి పొడవును కనుగొనడానికి అర్రే వస్తువు యొక్క అన్ని సూచికలపై లూప్ పునరావృతమవుతుంది.
- ఆ తరువాత, ' jsFunc() ” “str” వేరియబుల్‌లో నిల్వ చేయబడిన అర్రే ఆబ్జెక్ట్‌ని నిర్వచిస్తుంది.
- అప్పుడు, ' document.getElementById () ”పద్ధతి మొదటి ఖాళీ పేరాను దాని id “నమూనా” ద్వారా అర్రే ఆబ్జెక్ట్ “str”ని ప్రదర్శించడానికి యాక్సెస్ చేస్తుంది.
- చివరగా, “str” అర్రే ఆబ్జెక్ట్‌ని “తో అనుబంధించండి స్ట్రింగ్ లెంగ్త్() ” విధానం ప్రతి శ్రేణి సూచిక యొక్క స్ట్రింగ్ పొడవును లెక్కించి, ఆపై దానిని “పారా” ఐడి ఉన్న తదుపరి ఖాళీ పేరాలో చేర్చండి.
అవుట్‌పుట్
ఇక్కడ, అర్రే “ప్రోటోటైప్” కన్స్ట్రక్టర్ ద్వారా కొత్తగా జోడించబడిన “స్ట్రింగ్‌లెంగ్త్()” పద్ధతి సహాయంతో టార్గెట్ అర్రే ఆబ్జెక్ట్ యొక్క ప్రతి స్ట్రింగ్ యొక్క పొడవును అవుట్‌పుట్ చూపుతుంది.
ఉదాహరణ 2: కొత్త మెథడ్ “myUcase”ని సృష్టించడానికి “ప్రోటోటైప్” కన్‌స్ట్రక్టర్‌ని వర్తింపజేయడం మరియు దానిని అర్రే ఆబ్జెక్ట్‌కి వర్తింపజేయడం
ఈ ఉదాహరణ కొత్త “myUcase” పద్ధతిని సృష్టించడానికి “ప్రోటోటైప్” కన్స్ట్రక్టర్ను ఉపయోగిస్తుంది మరియు లక్ష్య శ్రేణి ఆబ్జెక్ట్‌కు దాన్ని వర్తిస్తుంది.
జావాస్క్రిప్ట్ కోడ్
దిగువ పేర్కొన్న జావాస్క్రిప్ట్ కోడ్ ద్వారా వెళ్దాం:
< స్క్రిప్ట్ >Array.prototype.myUcase = ఫంక్షన్ ( ) {
కోసం ( వీలు t = 0 ; t < ఈ.పొడవు; t++ ) {
ఇది [ t ] = ఇది [ t ] .to UpperCase ( ) ;
}
} ;
ఫంక్షన్ jsFunc ( ) {
const arrObj = [ 'html' , 'css' , 'జావాస్క్రిప్ట్' , 'స్పందించలేదు' ] ;
arrObj.myUcase ( ) ;
document.getElementById ( 'నమూనా' ) .innerHTML = arrObj;
}
స్క్రిప్ట్ >
ఇక్కడ, 'ప్రోటోటైప్' కన్స్ట్రక్టర్ '' అనే కొత్త పద్ధతిని సృష్టిస్తుంది. నా యుకేస్ 'అది ఉపయోగిస్తుంది' అప్పర్కేస్ 'అరే ఆబ్జెక్ట్ యొక్క ప్రతి స్ట్రింగ్‌ను 'అప్పర్కేస్'గా మార్చడానికి ఫంక్షన్ డెఫినిషన్‌లోని పద్ధతి. తరువాతి ఫంక్షన్‌లో, కస్టమ్ పద్ధతి శ్రేణిపై కూడా సూచించబడుతుంది.
అవుట్‌పుట్
చూసినట్లుగా, వర్తించే “myUcase()” పద్ధతి కారణంగా అర్రే ఆబ్జెక్ట్‌లోని ప్రతి స్ట్రింగ్ బటన్ క్లిక్‌పై క్యాపిటలైజ్ అవుతుంది.
ముగింపు
శ్రేణిని ఉపయోగించడానికి ' నమూనా ” జావాస్క్రిప్ట్‌లోని కన్స్ట్రక్టర్, దానితో కొత్త పద్ధతి/లక్షణాన్ని అనుబంధించండి. ఇది అవసరాలకు అనుగుణంగా కస్టమ్ పద్ధతిలో మరొక ఫంక్షన్ కోసం ఫంక్షనాలిటీలను నిర్వచించే ఒక ఫంక్షన్‌ను నిర్దేశిస్తుంది. ఈ గైడ్ జావాస్క్రిప్ట్‌లో అర్రే “ప్రోటోటైప్” కన్స్ట్రక్టర్ వినియోగాన్ని క్లుప్తంగా వివరించింది.