15 జావాస్క్రిప్ట్ శ్రేణి పద్ధతులు మీరు ఈరోజు ప్రావీణ్యం పొందాలి

ఆధునిక వెబ్‌సైట్‌లను అభివృద్ధి చేయడంలో జావాస్క్రిప్ట్ యొక్క ప్రాముఖ్యతను చూడటానికి రూకీ ప్రోగ్రామర్‌ల నుండి కోడింగ్ నిపుణుల వరకు అన్ని నైపుణ్య స్థాయిల వెబ్ డెవలపర్లు వస్తారు. జావాస్క్రిప్ట్ చాలా ప్రబలంగా ఉంది కాబట్టి మీరు వెబ్ యాప్‌లను సృష్టించబోతున్నారో లేదో తెలుసుకోవడం చాలా అవసరం.

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

---

---

జావాస్క్రిప్ట్ శ్రేణి పద్ధతులు అని పిలువబడే ఉపయోగకరమైన లక్షణాలను కూడా కలిగి ఉంది. డెవలపర్‌గా మీ నైపుణ్యాలను పెంచుకోవడానికి మీరు దగ్గరగా పరిశీలించాల్సిన పదిహేను ఇక్కడ ఉన్నాయి.

అర్రే పద్ధతులు అంటే ఏమిటి?

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

జావాస్క్రిప్ట్‌లోని శ్రేణి పద్ధతులు మీ శ్రేణి వేరియబుల్‌కి జోడించిన డాట్-నొటేషన్ ఉపయోగించి అమలు చేయబడతాయి. అవి కేవలం జావాస్క్రిప్ట్ విధులు కాబట్టి, అవి ఎల్లప్పుడూ ఐచ్ఛిక వాదనలను కలిగి ఉండే కుండలీకరణాలతో ముగుస్తాయి. అనే సాధారణ శ్రేణికి జోడించబడిన ఒక పద్ధతి ఇక్కడ ఉంది మైఅరే .

let myArray = [1,2,3]; myArray.pop();

ఈ కోడ్ అనే పద్ధతిని వర్తిస్తుంది పాప్ శ్రేణికి.

ఉదాహరణ శ్రేణి

ప్రతి ఉదాహరణ కోసం, మేము కాల్ చేసే నమూనా శ్రేణిని ఉపయోగించండి మైఅరే , పద్ధతులను నిర్వహించడానికి. మీ కన్సోల్ మరియు కోడ్‌ను లాగడానికి సంకోచించకండి.

---

---

let myArray = [2,4,5,7,9,12,14];

ఈ ఉదాహరణలు మీకు పునాది తెలుసు అని ఊహిస్తాయి జావాస్క్రిప్ట్ అంటే ఏమిటి మరియు అది ఎలా పనిచేస్తుంది . మీరు సరే కాకపోతే, నేర్చుకోవడానికి మరియు ఎదగడానికి మేమంతా ఇక్కడ ఉన్నాము.

ఈ పదిహేను శక్తివంతమైన శ్రేణి పద్ధతులను త్రవ్వండి!

---

---

1. అరే.పుష్ ​​()

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

అమలు చేయడం ద్వారా శ్రేణికి సంఖ్య 20 ని జోడించండి పుష్ () , 20 ని వాదనగా ఉపయోగించడం.

let myArray = [2,4,5,7,9,12,14];
myArray.push(20);

ఇది పని చేసిందో లేదో తనిఖీ చేయండి:

console.log(myArray); [2,4,5,7,9,12,14,20]

నడుస్తోంది పుష్ () myArray లోని పద్ధతి వాదనలో ఇచ్చిన విలువను శ్రేణిలో చేర్చింది. ఈ సందర్భంలో, 20. మీరు కన్సోల్‌లో myArray ని తనిఖీ చేసినప్పుడు, విలువ ఇప్పుడు శ్రేణి చివరలో జోడించబడిందని మీరు చూస్తారు.

2. Array.concat ()

ఇది ఏమి చేస్తుంది: కాన్కాట్ () రెండు లేదా అంతకంటే ఎక్కువ శ్రేణులను కొత్త శ్రేణిలో విలీనం చేయవచ్చు. ఇది ఇప్పటికే ఉన్న శ్రేణులను సవరించదు కానీ కొత్తదాన్ని సృష్టిస్తుంది.

తీసుకోవడం మైఅరే మరియు అనే శ్రేణిని విలీనం చేయండి న్యూఅరే దీనిలోనికి.

let myArray = [2,4,5,7,9,12,14];
let newArray = [1,2,3];
let result = myArray.concat(newArray); console.log(result); [2,4,5,7,9,12,14,1,2,3]

మీరు కలపాల్సిన బహుళ శ్రేణులు లేదా విలువలతో వ్యవహరించేటప్పుడు ఈ పద్ధతి అద్భుతంగా పనిచేస్తుంది, వేరియబుల్స్ ఉపయోగిస్తున్నప్పుడు అన్నీ ఒక సరళమైన దశలో ఉంటాయి.

3. అరే.జాయిన్ ()

ఇది ఏమి చేస్తుంది: చేరండి () ఒక శ్రేణిని తీసుకొని, కామాతో వేరు చేయబడిన శ్రేణిలోని విషయాలను కలుపుతుంది. ఫలితం స్ట్రింగ్‌లో ఉంచబడుతుంది. మీరు కామాకు ప్రత్యామ్నాయాన్ని ఉపయోగించాలనుకుంటే మీరు సెపరేటర్‌ని పేర్కొనవచ్చు.

MyArray ని ఉపయోగించి ఇది ఎలా పనిచేస్తుందో చూడండి. మొదట డిఫాల్ట్ పద్ధతిని సెపరేటర్ ఆర్గ్యుమెంట్ లేకుండా ఉపయోగించడం, ఇది కామాను ఉపయోగిస్తుంది.

let myArray = [2,4,5,7,9,12,14];
myArray.join(); '2,4,5,7,9,12,14'

జావాస్క్రిప్ట్ స్ట్రింగ్‌ను అవుట్‌పుట్ చేస్తుంది, శ్రేణిలోని ప్రతి విలువ కామాతో వేరు చేయబడుతుంది. సెపరేటర్‌ను మార్చడానికి మీరు ఫంక్షన్‌లో ఆర్గ్యుమెంట్‌ను ఉపయోగించవచ్చు. రెండు వాదనలతో గమనించండి: ఒకే స్థలం మరియు స్ట్రింగ్.

myArray.join(' ');
'2 4 5 7 9 12 14' myArray.join(' and ');
'2 and 4 and 5 and 7 and 9 and 12 and 14'

మొదటి ఉదాహరణ ఖాళీ, మీరు సులభంగా చదవగలిగే స్ట్రింగ్.

రెండవ ఉదాహరణ ఉపయోగిస్తుంది ('మరియు') , మరియు ఇక్కడ తెలుసుకోవడానికి రెండు విషయాలు ఉన్నాయి.

ముందుగా, మేము విలువలను వేరు చేయడానికి 'మరియు' అనే పదాన్ని ఉపయోగిస్తున్నాము. రెండవది, 'మరియు' అనే పదానికి రెండు వైపులా ఖాళీ ఉంది. ఉపయోగించినప్పుడు గుర్తుంచుకోవలసిన ముఖ్యమైన విషయం ఇది చేరండి () . జావాస్క్రిప్ట్ వాదనలను అక్షరాలా చదువుతుంది; కాబట్టి ఈ ఖాళీని వదిలివేస్తే, అంతా కలిసి స్క్రంచ్ చేయబడుతుంది (అనగా. '2and4and5 ...' మొదలైనవి) చాలా చదవగలిగే అవుట్‌పుట్ కాదు!

4. ప్రతి () కోసం శ్రేణి

ఇది ఏమి చేస్తుంది: ప్రతి() (కేస్ సెన్సిటివ్!) మీ శ్రేణిలోని ప్రతి అంశంపై ఒక ఫంక్షన్‌ను నిర్వహిస్తుంది. ఈ ఫంక్షన్ మీరు సృష్టించే ఏదైనా ఫంక్షన్, శ్రేణికి ఫంక్షన్‌ను వర్తింపజేయడానికి 'ఫర్' లూప్‌ని ఉపయోగించడం లాంటిది, కానీ కోడ్‌కి చాలా తక్కువ పని ఉంటుంది.

ఇంకా కొంచెం ఎక్కువ ఉంది ప్రతి() ; వాక్యనిర్మాణం చూడండి, ఆపై ప్రదర్శించడానికి ఒక సాధారణ ఫంక్షన్ చేయండి.


myArray.forEach(function(item){
//code
});


మేము ఉపయోగిస్తున్నాము మైఅరే , ప్రతి() డాట్ నొటేషన్‌తో వర్తించబడుతుంది. ఆర్గ్యుమెంట్ కుండలీకరణం లోపల మీరు ఉపయోగించాలనుకుంటున్న ఫంక్షన్‌ను మీరు ఉంచండి ఫంక్షన్ (అంశం) ఉదాహరణలో.

ఒక్కసారి దీనిని చూడు ఫంక్షన్ (అంశం) . ఇది forEach () లోపల అమలు చేయబడిన ఫంక్షన్, మరియు దాని స్వంత వాదన ఉంది. మేము వాదనను పిలుస్తున్నాము అంశం . ఈ వాదన గురించి తెలుసుకోవడానికి రెండు విషయాలు ఉన్నాయి:

• ForEach () మీ శ్రేణిపై లూప్ చేసినప్పుడు, అది ఈ వాదనకు కోడ్‌ని వర్తిస్తుంది. ప్రస్తుత మూలకాన్ని కలిగి ఉన్న తాత్కాలిక వేరియబుల్‌గా ఆలోచించండి.
• మీరు ఆర్గ్యుమెంట్ పేరును ఎంచుకుంటారు, దానికి మీకు కావలసిన ఏదైనా పేరు పెట్టవచ్చు. సాధారణంగా దీనికి 'ఐటెమ్' లేదా 'ఎలిమెంట్' వంటి అర్థమయ్యేలా సులభంగా పేరు పెట్టబడుతుంది.

ఆ రెండు విషయాలను దృష్టిలో ఉంచుకుని, ఈ సాధారణ ఉదాహరణను చూడండి. ప్రతి విలువకు 15 ని జోడించి, ఫలితాన్ని కన్సోల్‌లో చూపించండి.


myArray.forEach(function(item){
console.log(item + 15);
});


మేము ఉపయోగిస్తున్నాము అంశం ఈ ఉదాహరణలో వేరియబుల్, కాబట్టి ఫంక్షన్ ద్వారా ప్రతి విలువకు 15 జోడించడానికి వ్రాయబడింది అంశం . కన్సోల్ ఫలితాలను ముద్రిస్తుంది. Google Chrome కన్సోల్‌లో ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది.

ఫలితం శ్రేణిలోని ప్రతి సంఖ్య, కానీ దానికి 15 జోడించబడింది!

5. అరే.మ్యాప్ ()

ఇది ఏమి చేస్తుంది: మ్యాప్ () మీ శ్రేణిలోని ప్రతి మూలకంపై ఒక ఫంక్షన్‌ను నిర్వహిస్తుంది మరియు ఫలితాన్ని కొత్త శ్రేణిలో ఉంచుతుంది.

ప్రతి మూలకంపై ఒక ఫంక్షన్‌ను అమలు చేయడం forEach () లాగా ఉంటుంది. ఇక్కడ తేడా ఏమిటంటే మ్యాప్ () అమలు చేసినప్పుడు కొత్త శ్రేణిని సృష్టిస్తుంది. forEach () కొత్త శ్రేణిని స్వయంచాలకంగా సృష్టించదు, అలా చేయడానికి మీరు నిర్దిష్ట ఫంక్షన్‌ను కోడ్ చేయాలి.

MyArray లోని ప్రతి మూలకం విలువను రెట్టింపు చేయడానికి మ్యాప్ () ఉపయోగించండి మరియు వాటిని కొత్త శ్రేణిలో ఉంచండి. మీరు అదే చూస్తారు ఫంక్షన్ (అంశం) కొంచెం ఎక్కువ అభ్యాసం కోసం వాక్యనిర్మాణం.

let myArray = [2,4,5,7,9,12,14]; let doubleArray = myArray.map(function(item){
return item * 2;
});

కన్సోల్‌లో ఫలితాలను తనిఖీ చేయండి.

console.log(doubleArray); [4,8,10,14,18,24,28]

మైఅరే మారదు:

console.log(myArray); [2,4,5,7,9,12,14]

6. అరే.అన్‌షిఫ్ట్ ()

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

let myArray = [2,4,5,7,9,12,14];
myArray.unshift(0);

కన్సోల్‌కు శ్రేణిని లాగిన్ చేసినప్పుడు, మీరు శ్రేణి ప్రారంభంలో 0 సంఖ్యను చూడాలి.

console.log(myArray); [0, 2,4,5,7,9,12,14]

7. అరే.సార్ట్ ()

ఇది ఏమి చేస్తుంది: శ్రేణిలో నిర్వహించే అత్యంత సాధారణ ఆపరేషన్లలో సార్టింగ్ ఒకటి మరియు ఇది చాలా ఉపయోగకరంగా ఉంటుంది. జావాస్క్రిప్ట్ క్రమబద్ధీకరించు () సంఖ్యల శ్రేణిని లేదా స్ట్రింగ్‌లను కూడా కేవలం ఒకే లైన్ కోడ్‌తో క్రమబద్ధీకరించడానికి అర్రే పద్ధతిని ఉపయోగించవచ్చు. ఈ ఆపరేషన్ స్థానంలో ఉంది మరియు ప్రారంభ శ్రేణిని సవరించడం ద్వారా క్రమబద్ధీకరించబడిన శ్రేణిని అందిస్తుంది. కోసం వేరే సంఖ్యల సంఖ్యను తీసుకోండి మైఅరే ఈసారి.

let myArray = [12, 55, 34, 65, 10];
myArray.sort((a,b) => a - b);

సార్టింగ్ స్థానంలో జరుగుతుంది కాబట్టి, మీరు క్రమబద్ధీకరించిన శ్రేణి కోసం ప్రత్యేక వేరియబుల్‌ని ప్రకటించాల్సిన అవసరం లేదు.

console.log(myArray); [10, 12, 34, 55, 65]

డిఫాల్ట్‌గా, శ్రేణి ఆరోహణ క్రమంలో క్రమబద్ధీకరించబడింది, కానీ మీరు ఐచ్ఛికంగా అనుకూల ఫంక్షన్‌ను పాస్ చేయవచ్చు క్రమబద్ధీకరించు () కావలసిన పద్ధతిలో శ్రేణిని క్రమబద్ధీకరించే పద్ధతి. ఈ సందర్భంలో, నేను ఒక ఆచారాన్ని ఆమోదించాను బాణం ఫంక్షన్ శ్రేణిని సంఖ్యాపరంగా ఆరోహణ క్రమంలో క్రమబద్ధీకరించడానికి.

8. Array. రివర్స్ ()

ఇది ఏమి చేస్తుంది: పేరు సూచించినట్లుగా, ది రివర్స్ () శ్రేణిలోని మూలకాల క్రమాన్ని రివర్స్ చేయడానికి పద్ధతి ఉపయోగించబడుతుంది. ఇది శ్రేణిలోని విషయాలను రివర్స్ చేయదని గమనించండి, కేవలం ఆర్డర్ మాత్రమే. ఈ పద్ధతిని బాగా అర్థం చేసుకోవడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది:

let myArray = [2,4,5,7,9,12,14];
myArray.reverse()

ఆపరేషన్‌ను ధృవీకరించడానికి అవుట్‌పుట్‌ను కన్సోల్‌కి లాగ్ చేయండి.

console.log(myArray); [14, 12, 9, 7, 5, 4, 2]

మీరు గమనిస్తే, మూలకాల క్రమం తిరగబడింది. గతంలో, చివరి సూచిక వద్ద మూలకం (సూచిక 6 వద్ద మూలకం 14) ఇప్పుడు సున్న సూచిక వద్ద మూలకం మరియు మొదలైనవి.

9. అరే.స్లైస్ ()

ఇది ఏమి చేస్తుంది: ముక్క () శ్రేణి యొక్క భాగం యొక్క నిస్సార కాపీని తిరిగి పొందడానికి ఉపయోగించబడుతుంది. సరళంగా చెప్పాలంటే, ఈ పద్ధతి శ్రేణి నుండి నిర్దిష్ట మూలకాలను వాటి సూచిక ద్వారా ఎంచుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు తిరిగి పొందాలనుకుంటున్న మూలకం యొక్క ప్రారంభ సూచిక మరియు మూలకాలు మరియు ఐచ్ఛికంగా ముగింపు సూచికను కూడా పాస్ చేయవచ్చు.

మీరు ముగింపు సూచికను అందించకపోతే, ప్రారంభ సూచిక నుండి శ్రేణి చివరి వరకు అన్ని అంశాలు తిరిగి పొందబడతాయి. ఈ పద్ధతి కొత్త శ్రేణిని అందిస్తుంది మరియు ఇప్పటికే ఉన్నదాన్ని సవరించదు.

let myArray = [2,4,5,7,9,12,14];
let slicedArray = myArray.slice(2);

పై కోడ్‌లో, ఎండ్ ఇండెక్స్ పారామీటర్ పాస్ అవ్వనందున రెండవ ఇండెక్స్ నుండి చివరి ఇండెక్స్ వరకు అన్ని ఎలిమెంట్‌లు తిరిగి పొందబడతాయి. రెండు శ్రేణులను కన్సోల్‌కి లాగ్ చేయండి.

console.log(myArray);
console.log(slicedArray); [2, 4, 5, 7, 9, 12, 14]
[5, 7, 9, 12, 14]


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

let myArray = [2,4,5,7,9,12,14];
let slicedArray = myArray.slice(1, 3);
console.log(slicedArray); [4, 5]

10. Array.splice ()

ఇది ఏమి చేస్తుంది: స్ప్లైస్ () అనేది శ్రేణిలోని మూలకాలను తొలగించడానికి లేదా భర్తీ చేయడానికి ఉపయోగించే సహాయక శ్రేణి పద్ధతి. తొలగించాల్సిన మూలకాల సూచిక మరియు సంఖ్యను పేర్కొనడం ద్వారా, అది శ్రేణిని సవరించును.

let myArray = [2,4,5,7,9,12,14];
myArray.splice(2, 3);
console.log(myArray);

పై ఉదాహరణలో, ది మైఅరే సూచిక 2 నుండి శ్రేణి విభజించబడింది మరియు దాని నుండి 3 మూలకాలు తీసివేయబడతాయి. శ్రేణి ఇప్పుడు వీటిని కలిగి ఉంటుంది:

[2, 4, 12, 14]

మూలకాలను తొలగించడం కంటే వాటిని భర్తీ చేయడానికి, మీరు భర్తీ చేయదలిచిన అంశాలతో ఎన్ని ఐచ్ఛిక పారామితులను అయినా పాస్ చేయవచ్చు, ఇలా:

విండోస్ 7 పనిచేయని సిస్టమ్ పునరుద్ధరణ

let myArray = [2,4,5,7,9,12,14];
myArray.splice(2, 3, 1, 2, 3);
console.log(myArray); [2, 4, 1, 2, 3, 12, 14]

11. అరే.ఫిల్టర్ ()

అది ఏమి చేస్తుంది: ది ఫిల్టర్ () పద్ధతి అనేది ఉపయోగకరమైన శ్రేణి పద్ధతి, ఇది పరీక్షను కలిగి ఉన్న ఫంక్షన్‌ను తీసుకుంటుంది మరియు ఆ పరీక్షలో ఉత్తీర్ణులైన అన్ని అంశాలతో కొత్త శ్రేణిని అందిస్తుంది. దాని పేరుకు అనుగుణంగా, ఇతర మూలకాల నుండి మీకు అవసరమైన మూలకాలను ఫిల్టర్ చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. బూలియన్ విలువను అందించే ఫంక్షన్‌ను ఉపయోగించి వడపోత జరుగుతుంది.

ఇక్కడ ఒక ఉదాహరణ ఫిల్టర్ () 2 ద్వారా భాగించబడే శ్రేణి నుండి ఆ మూలకాలను మాత్రమే పొందడానికి ఉపయోగించే పద్ధతి.

let myArray = [2,4,5,7,9,12,14];
let divisibleByTwo = myArray.filter((number) => number % 2 === 0);
console.log(divisibleByTwo);

పై ఉదాహరణలో, బాణం ఫంక్షన్ పారామీటర్‌గా పంపబడుతుంది, ఇది అసలు శ్రేణి నుండి ప్రతి సంఖ్యను తీసుకుంటుంది మరియు మాడ్యులో ఉపయోగించి 2 ద్వారా భాగిస్తే తనిఖీ చేయబడుతుంది ( % ) మరియు సమానత్వం ( === ) ఆపరేటర్. అవుట్‌పుట్ ఎలా ఉంటుందో ఇక్కడ ఉంది:

[2, 4, 12, 14]

12. శ్రేణి. తగ్గించు ()

ఇది ఏమి చేస్తుంది: తగ్గించు () రీడ్యూసర్ ఫంక్షన్ తీసుకునే మరియు తిరిగి వచ్చేటప్పుడు ఒకే విలువను అవుట్‌పుట్ చేయడానికి ప్రతి శ్రేణి మూలకంపై అమలు చేసే శ్రేణి పద్ధతి. ఇది అవసరమైన పారామితులుగా అక్యుమ్యులేటర్ వేరియబుల్ మరియు కరెంట్ ఎలిమెంట్ వేరియబుల్‌తో రీడ్యూసర్ ఫంక్షన్‌ను తీసుకుంటుంది. సంచిత విలువ అన్ని పునరావృతాలలో గుర్తుంచుకోబడుతుంది మరియు తుది పునరావృతం తర్వాత చివరికి తిరిగి వస్తుంది.

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

let myArray = [2,4,5,7,9,12,14];
let sumOfNums = myArray.reduce((sum, currentNum) => sum + currentNum, 0);

పై ఉదాహరణలో 0 రెండవ పరామితిగా ఆమోదించబడింది, ఇది సంచిత వేరియబుల్ యొక్క ప్రారంభ విలువగా ఉపయోగించబడుతుంది. ది sumOfNums వేరియబుల్ యొక్క రిటర్న్ విలువను కలిగి ఉంటుంది తగ్గించు () శ్రేణిలోని అన్ని మూలకాల మొత్తంగా భావించే పద్ధతి.

console.log(sumOfNums); 53

13. శ్రేణి.

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

let myArray = [2,4,5,7,9,12,14];
console.log(myArray.includes(4));
console.log(myArray.includes(2, 1));
console.log(myArray.includes(12, 2));
console.log(myArray.includes(18));

ఈ పద్ధతి అవసరమైన పరామితి, శోధించడానికి మూలకం మరియు ఐచ్ఛిక పరామితి, నుండి శోధించడం ప్రారంభించడానికి శ్రేణి సూచికను తీసుకుంటుంది. ఆ మూలకం ఉందా లేదా అనేదానిపై ఆధారపడి, అది తిరిగి వస్తుంది నిజం లేదా తప్పుడు వరుసగా. అందువల్ల, అవుట్‌పుట్ ఇలా ఉంటుంది:

true
false
true
false

14. Array.indexOf ()

ఇది ఏమి చేస్తుంది: ఇండెక్స్ ఆఫ్ () పేర్కొన్న మూలకం యొక్క మొదటి సంభవించిన శ్రేణిలో కనిపించే సూచికను కనుగొనడానికి పద్ధతి ఉపయోగించబడుతుంది. ఇది చేర్చడం () పద్ధతిని పోలి ఉన్నప్పటికీ, ఈ పద్ధతి సంఖ్యా సూచిక లేదా -1 మూలకం శ్రేణిలో లేనట్లయితే అందిస్తుంది.

let myArray = [2,4,5,7,9,12,14];
console.log(myArray.indexOf(4));
console.log(myArray.indexOf('4'));
console.log(myArray.indexOf(9, 2));

ఇండెక్స్ ఆఫ్ () ఒక మూలకం ఉందో లేదో తనిఖీ చేయడానికి పద్ధతి కఠినమైన సమానత్వాన్ని ఉపయోగిస్తుంది, అంటే విలువ, అలాగే డేటా రకం ఒకేలా ఉండాలి. ఐచ్ఛిక రెండవ పరామితి శోధనను ప్రారంభించడానికి సూచికను తీసుకుంటుంది. ఈ ప్రమాణాల ఆధారంగా, అవుట్‌పుట్ ఇలా కనిపిస్తుంది:

1
-1
4

15. అరే.ఫిల్ ()

ఇది ఏమి చేస్తుంది: తరచుగా, మీరు శ్రేణిలోని అన్ని విలువలను 0. వంటి స్టాటిక్ విలువకు సెట్ చేయాల్సి రావచ్చు, మీరు లూప్‌ను ఉపయోగించడానికి బదులుగా, మీరు ప్రయత్నించవచ్చు పూరించండి () అదే ప్రయోజనం కోసం పద్ధతి. మీరు ఈ పద్ధతిని 1 అవసరమైన పారామీటర్‌తో శ్రేణిలో కాల్ చేయవచ్చు: శ్రేణిని పూరించడానికి విలువ మరియు 2 ఐచ్ఛిక పారామితులు: ప్రారంభం మరియు ముగింపు సూచిక మధ్య పూరించడానికి. ఈ పద్ధతి నిష్క్రమణ శ్రేణిని సవరించింది.

let myArray = [2,4,5,7,9,12,14];
let array1 = myArray.fill(0);
myArray = [2,4,5,7,9,12,14];
let array2 = myArray.fill(0, 2);
myArray = [2,4,5,7,9,12,14];
let array3 = myArray.fill(0, 1, 3);

అవుట్‌పుట్‌ను కన్సోల్‌కి లాగిన్ చేసినప్పుడు, మీరు చూస్తారు:

console.log(array1);
console.log(array2);
console.log(array3); [0, 0, 0, 0, 0, 0, 0]
[2, 4, 0, 0, 0, 0, 0]
[2, 0, 0, 7, 9, 12, 14]

మీ జావాస్క్రిప్ట్ జర్నీలో తదుపరి దశలు

శ్రేణులు జావాస్క్రిప్ట్ భాషలో శక్తివంతమైన భాగం, అందుకే డెవలపర్‌గా మీ జీవితాన్ని సులభతరం చేయడానికి అనేక పద్ధతులు అంతర్నిర్మితంగా ఉన్నాయి. ఈ పదిహేను పద్ధతులలో నైపుణ్యం సాధించడానికి ఉత్తమ మార్గం సాధన.

మీరు జావాస్క్రిప్ట్ నేర్చుకోవడం కొనసాగిస్తున్నప్పుడు, MDN ఒక గొప్ప వనరు వివరణాత్మక డాక్యుమెంటేషన్ కోసం. కన్సోల్‌లో సౌకర్యవంతంగా ఉండండి, ఆపై ప్రోగ్రామర్‌ల కోసం ఉత్తమ జావాస్క్రిప్ట్ ఎడిటర్‌లతో మీ నైపుణ్యాలను మెరుగుపరచండి. జావాస్క్రిప్ట్‌తో మీ వెబ్‌సైట్‌ను రూపొందించడానికి సిద్ధంగా ఉన్నారా? మీరు పరిగణించగల కొన్ని ఫ్రేమ్‌వర్క్‌లను ఎందుకు పరిశీలించకూడదు.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ 6 జావాస్క్రిప్ట్ ఫ్రేమ్‌వర్క్స్ వర్త్ లెర్నింగ్

అభివృద్ధికి సహాయపడటానికి అక్కడ అనేక జావాస్క్రిప్ట్ ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి. మీరు తెలుసుకోవలసిన కొన్ని ఇక్కడ ఉన్నాయి.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావాస్క్రిప్ట్
• కోడింగ్ చిట్కాలు

రచయిత గురుంచి నితిన్ రంగనాథ్(31 కథనాలు ప్రచురించబడ్డాయి)

నితిన్ ఆసక్తిగల సాఫ్ట్‌వేర్ డెవలపర్ మరియు కంప్యూటర్ ఇంజనీరింగ్ విద్యార్థి జావాస్క్రిప్ట్ టెక్నాలజీలను ఉపయోగించి వెబ్ అప్లికేషన్‌లను అభివృద్ధి చేస్తున్నాడు. అతను ఫ్రీలాన్స్ వెబ్ డెవలపర్‌గా పనిచేస్తాడు మరియు తన ఖాళీ సమయంలో లైనక్స్ మరియు ప్రోగ్రామింగ్ కోసం వ్రాయడానికి ఇష్టపడతాడు.

నితిన్ రంగనాథ్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి