జావాస్క్రిప్ట్లో అర్రే మెథడ్స్: అర్రే పద్ధతుల గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ

ఒక పరిష్కారాన్ని కోడ్ చేయాలని యోచిస్తున్నప్పుడు సమర్థత చాలా ముఖ్యం. లో శ్రేణి వస్తువు వివిధ పద్ధతులను కలిగి ఉంటుంది. ఈ పద్ధతులు వాటి సమర్థవంతమైన పరుగు కోసం సంకేతాలలో ఉపయోగించబడతాయి. ఈ వ్యాసం జావాస్క్రిప్ట్‌లోని వివిధ శ్రేణి పద్ధతులపై దృష్టి పెడుతుంది.

ఈ వ్యాసంలో క్రింది పాయింటర్లు టచ్ అప్ అవుతాయి:

• కాంకాట్ విధానం
• కాపీ విథిన్ విధానం
• ప్రతి పద్ధతి
• టోస్ట్రింగ్ విధానం
• చేరండి విధానం
• పాప్ మరియు పుష్ విధానం
• షిఫ్ట్ మరియు అన్షిఫ్ట్ విధానం
• స్ప్లైస్ విధానం
• స్లైస్ విధానం
• ప్రతి విధానం

ఈ వ్యాసం యొక్క మొదటి అంశంతో కొనసాగిద్దాం,

జావాస్క్రిప్ట్లో శ్రేణి పద్ధతులు

కాంకాట్ విధానం

కాంకాట్ () పద్ధతి 2 లేదా అంతకంటే ఎక్కువ శ్రేణులలో కలుస్తుంది, ఆపై చేరిన శ్రేణి యొక్క కాపీని తిరిగి ఇస్తుంది.

var alphabet = ['r', 's', 't'] var num = [5, 6, 7] var AlphabetNum = alphabet.concat (num) document.write ('AlphabetNum:' + AlphabetNum)

ఇచ్చిన ఉదాహరణలో, కాంకాట్ పద్ధతి రెండు శ్రేణుల వర్ణమాల మరియు సంఖ్యలతో కలుస్తుంది మరియు క్రొత్త సంగ్రహణ శ్రేణిని అందిస్తుంది: ఆల్ఫాబెట్ నమ్.

అవుట్పుట్:

ఆల్ఫాబెట్ నమ్: r, s, t, 5,6,7

తదుపరిది కాపీ విథిన్ విధానం,

కాపీ విథిన్ విధానం

జావాస్క్రిప్ట్‌లో ఉన్న కాపీ విథిన్ () పద్ధతి శ్రేణిలోని కొంత భాగాన్ని అదే శ్రేణిలోకి కాపీ చేసి, దానిని తిరిగి ఇస్తుంది.

సింటాక్స్:

array.copyWithin (లక్ష్యం, ప్రారంభం, ముగింపు)

ఈ పద్ధతి మూడు పారామితులను కలిగి ఉంటుంది:

• లక్ష్యం: మూలకం కాపీ చేయవలసిన సూచిక స్థానం. లక్ష్యాన్ని పేర్కొనడం తప్పనిసరి.
• ప్రారంభం: మూలకాలను కాపీ చేయడం ప్రారంభించడానికి సూచిక స్థానం. ఇది ఐచ్ఛికం. ప్రారంభ డిఫాల్ట్ విలువ 0.
• ముగింపు: మూలకాన్ని కాపీ చేసే విధానాన్ని ముగించడానికి సూచిక స్థానం. ఇది కూడా ఐచ్ఛిక పరామితి, మరియు డిఫాల్ట్ విలువ పొడవు .

var సంఖ్య = ['ఒకటి', 'రెండు', 'మూడు', 'నాలుగు', 'ఐదు', 'ఆరు', 'ఏడు'] document.write (number) document.write (' 
'+ number.copyWithin (3,0,4%)

అవుట్పుట్:

ఒకటి రెండు మూడు నాలుగు ఐదు ఆరు ఏడు

ఒకటి, రెండు, మూడు, ఒకటి, రెండు, మూడు, నాలుగు

ఉదాహరణలో చూపినట్లుగా, శ్రేణిలోని విలువలు ఒకే శ్రేణికి కాపీ చేయబడతాయి. లక్ష్య సూచిక: 3, ప్రారంభ సూచిక: 0 మరియు ముగింపు సూచిక: 4.

జావాస్క్రిప్ట్‌లోని ఈ అర్రే పద్ధతుల్లో తదుపరి బిట్,

ప్రతి పద్ధతి

ఈ పద్ధతి శ్రేణిలో ఉన్న అన్ని అంశాలు పేర్కొన్న పరిస్థితిని సంతృప్తిపరుస్తాయా అని పరిశీలిస్తుంది లేదా తనిఖీ చేస్తుంది. పద్ధతి యొక్క వాక్యనిర్మాణం క్రింది విధంగా ఉంది:

array.every (ఫంక్షన్ [, This_arg])

ఈ ఫంక్షన్ కోసం వాదన మరొక ఫంక్షన్. ఇది తప్పక తనిఖీ చేయవలసిన పరిస్థితిని నిర్వచిస్తుంది. దీనికి క్రింది వాదనలు ఉన్నాయి:

• అర్రే: ప్రతి () ఫంక్షన్ అని పిలువబడే శ్రేణి. ఇది ఐచ్ఛిక వాదన.
• సూచిక: ప్రస్తుత మూలకం యొక్క సూచిక. ఇది కూడా ఐచ్ఛికం.
• మూలకం: ఫంక్షన్ ద్వారా ప్రాసెస్ చేయబడుతున్న ప్రస్తుత మూలకం. ఈ వాదనను ఉపయోగించడం తప్పనిసరి.

ఉపయోగించాల్సిన ఫంక్షన్‌ను చెప్పడానికి ఈ_ఆర్గ్ ఉపయోగించబడుతుంది ఇది విలువ. కింది ఉదాహరణలో, శ్రేణిలోని ప్రతి మూలకం సానుకూలంగా ఉందా లేదా అని మేము తనిఖీ చేస్తాము.

ఫంక్షన్ పాజిటివ్ (ఎలిమెంట్, ఇండెక్స్, అర్రే) {రిటర్న్ ఎలిమెంట్> 0} ఫంక్షన్ ఫంక్ () {var అర్రే = [11, 89, 23, 7, 98] // సానుకూల సంఖ్య కోసం తనిఖీ చేయండి var value = array.every (positive) పత్రం .రైట్ (విలువ)} func ()

ఫంక్షన్ నిజమైన లేదా తప్పుడు పరంగా విలువను తిరిగి ఇస్తుందని గమనించాలి. శ్రేణిలో ఉన్న అన్ని అంశాలు సానుకూలంగా ఉన్నందున, అవుట్పుట్ ఇలా ఉంటుంది:

నిజం

తదుపరిది టోస్ట్రింగ్ పద్ధతి.

టోస్ట్రింగ్ విధానం

ఈ పద్ధతి సంఖ్యను స్ట్రింగ్‌గా మారుస్తుంది. మూల విలువను పేర్కొనడం ద్వారా సంఖ్యలను మార్చవచ్చు.

var సంఖ్య = 569 document.write ('అవుట్‌పుట్:' + number.toString ())

ఇచ్చిన ఉదాహరణలో, toString () పద్ధతిని ఏ పరామితి లేదా మూల విలువ లేకుండా పిలుస్తారు.

అవుట్పుట్:

569

ఇప్పుడు చేరిన పద్ధతిని పరిశీలిద్దాం,

చేరండి విధానం

చేరండి () పద్ధతి శ్రేణిలో ఉన్న ప్రతి మూలకంలో కలుస్తుంది. అదనంగా, మూలకాలను వేరు చేయడానికి మేము ఒక విభజనను పేర్కొనవచ్చు.

var a = new array ('I', 'Love', 'Music') var string = a.join () document.write ('string:' + string) var string = a.join ('*') పత్రం. వ్రాయడానికి(' 
స్ట్రింగ్: '+ స్ట్రింగ్) var స్ట్రింగ్ = a.join (' + ') document.write (' 
స్ట్రింగ్: '+ స్ట్రింగ్)

అందించిన ఉదాహరణలో, చేరడానికి మొదటి పద్ధతిలో ఏ సెపరేటర్ ఉండదు, అందువలన డిఫాల్ట్ సెపరేటర్ ఉపయోగించబడుతుంది. ఇతర రెండు పద్ధతులలో, “*“ మరియు “+” పేర్కొన్న ఆపరేటర్లు.

అవుట్పుట్:

స్ట్రింగ్: ఐ, లవ్, మ్యూజిక్

స్ట్రింగ్: ఐ * లవ్ * మ్యూజిక్

స్ట్రింగ్: ఐ + లవ్ + మ్యూజిక్

జావాస్క్రిప్ట్‌పై శ్రేణి పద్ధతులపై ఈ వ్యాసంలో తదుపరిది,

పాప్ మరియు పుష్ విధానం

పాప్ () పద్ధతి ఒక శ్రేణి చివరి నుండి మూలకాన్ని తొలగిస్తుంది, ఇది స్టాక్ లాగా ఉంటుంది. మరోవైపు, పుష్ () పద్ధతి, శ్రేణి చివరికి ఒక మూలకాన్ని జోడిస్తుంది.

పద్ధతులు LIFO (లాస్ట్-ఇన్-ఫస్ట్-అవుట్) భావనను అమలు చేస్తాయి.

['రాక్', 'మెటల్', 'బ్లూస్', 'జాజ్'] list.pop () ['రాక్', 'మెటల్', 'బ్లూస్']

కోడ్ శ్రేణిలోని చివరి మూలకాన్ని తొలగిస్తుంది, అనగా “జాజ్”.

పుష్ () పద్ధతి మూలకాన్ని తిరిగి శ్రేణికి జోడిస్తుంది.

['రాక్', 'మెటల్', 'బ్లూస్'] list.push ('జాజ్') ['రాక్', 'మెటల్', 'బ్లూస్', 'జాజ్']

మరింత ముందుకు వెళ్దాం,

షిఫ్ట్ మరియు అన్షిఫ్ట్ విధానం

షిఫ్ట్ () పద్ధతి శ్రేణి ప్రారంభం నుండి మూలకాన్ని తొలగిస్తుంది. మరోవైపు, అన్ షిఫ్ట్ () పద్ధతి, శ్రేణి యొక్క మూలకానికి తిరిగి మూలకాన్ని జోడిస్తుంది.

['రాక్', 'మెటల్', 'బ్లూస్', 'జాజ్'] list.shift () ['మెటల్', 'బ్లూస్', 'జాజ్']

కోడ్ మొదటి మూలకాన్ని తొలగిస్తుంది, అనగా శ్రేణి నుండి రాక్.

అన్షిఫ్ట్ () పద్ధతిని ఉపయోగించినప్పుడు, “రాక్” తిరిగి శ్రేణికి జోడించబడుతుంది.

['రాక్', 'మెటల్', 'బ్లూస్', 'జాజ్'] list.unshift ('రాక్') ['రాక్ ',' మెటల్', 'బ్లూస్', 'జాజ్']

మేము జావాస్క్రిప్ట్ బ్లాగులో ఈ శ్రేణి పద్ధతుల యొక్క చివరి బిట్స్‌లో ఉన్నాము,

స్ప్లైస్ విధానం

స్ప్లైస్ () పద్ధతి శ్రేణి యొక్క నిర్దిష్ట లేదా ఎంచుకున్న భాగాన్ని తొలగిస్తుంది. ఇది శ్రేణికి మూలకాలను తొలగించడం, భర్తీ చేయడం లేదా జోడించడం యొక్క వనరుల పద్ధతి అని రుజువు చేస్తుంది.

['రాక్', 'మెటల్', 'బ్లూస్', 'జాజ్'] list.splice (2, 1) // ఇండెక్స్ స్థానం 2 నుండి ప్రారంభించి, ఒక మూలకాన్ని తొలగించండి ['రాక్', 'మెటల్', 'జాజ్'] జాబితా .splice (2,2) // ఇండెక్స్ స్థానం 2 నుండి ప్రారంభించి, రెండు అంశాలను తొలగించండి ['రాక్', 'మెటల్']

పై ఉదాహరణలో, స్లైస్ పద్ధతి పేర్కొన్న సూచిక ప్రకారం మూలకాలను తొలగిస్తుంది.

ఇండెక్స్ 2 వద్ద ఉంచినందున “బ్లూస్” మొదటి ఉదాహరణ నుండి తొలగించబడుతుంది.

జావాలో jframe ఎలా తయారు చేయాలి

రెండవ ఉదాహరణలో, రెండు అంశాలు అనగా “బ్లూస్” మరియు “జాజ్” తొలగించబడతాయి, ఎందుకంటే ఇండెక్స్ 2 నుండి మొదలుకొని 2 మూలకాలను తొలగించాలని సూచిక నిర్దేశిస్తుంది.

జావాస్క్రిప్ట్‌లో శ్రేణులు సున్నా-సూచికగా ఉన్నాయని గమనించాలి.

స్లైస్ విధానం

స్లైస్ () పద్ధతి ప్రారంభ శ్రేణి నుండి ఒక మూలకాన్ని ముక్కలు చేస్తుంది మరియు ఆ మూలకాన్ని కలిగి ఉన్న క్రొత్త శ్రేణిని అందిస్తుంది. స్లైస్ () పద్ధతి ప్రారంభ శ్రేణి నుండి ఏ మూలకాన్ని తొలగించదని గమనించాలి.

var శ్రేణి = ['రాక్', 'పాప్', 'జాజ్', 'బ్లూస్', 'మెటల్'] document.write ('array.slice (1, 2):' + array.slice (1, 2%) పత్రం .వ్రాయడానికి(' 
array.slice (1, 3): '+ array.slice (1, 3%)

కింది కోడ్ యొక్క అవుట్పుట్ క్రింది విధంగా ఉంది:

array.slice (1, 2): పాప్

array.slice (1, 3): పాప్, జాజ్

జావాస్క్రిప్ట్‌లో ఈ శ్రేణి పద్ధతిలో చివరి పద్ధతి,

ప్రతి విధానం

ఈ పద్ధతి శ్రేణిలో ఉన్న ప్రతి మూలకం యొక్క ఫంక్షన్‌ను పిలుస్తుంది.

ఫంక్షన్ funct () {// ప్రారంభ శ్రేణి const అంశాలు = [2, 18, 28] const copy = [] items.forEach (ఫంక్షన్ (అంశం) {copy.push (item * item)}) document.write (copy)} funct ()

ఉదాహరణలో, శ్రేణిలో ఉన్న ప్రతి మూలకం యొక్క చతురస్రాన్ని మేము లెక్కిస్తాము.

అవుట్పుట్ క్రింది విధంగా ఉంది:

4,324,784

దీనితో మనం ‘జావాస్క్రిప్ట్‌లో అర్రే మెథడ్’ లో ఈ బ్లాగ్ చివరికి వచ్చాము. మీరు ఈ సమాచార మరియు సహాయకారిని కనుగొన్నారని నేను నమ్ముతున్నాను, ఇలాంటి అంశాలపై మరిన్ని ట్యుటోరియల్స్ కోసం వేచి ఉండండి. మీరు మా శిక్షణా కార్యక్రమాన్ని కూడా తనిఖీ చేయవచ్చుj క్వెరీపై దాని వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానాన్ని పొందండి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం.

మాకు ప్రశ్న ఉందా? ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి మరియు మేము మీ వద్దకు తిరిగి వస్తాము.