డేటాను బల్క్‌లో డీల్ చేస్తున్నప్పుడు, అప్‌డేట్ కారణంగా కొన్ని ఎంట్రీలను తీసివేయాల్సిన అవసరం ఉంటుంది. ఉదాహరణకు, నిర్దిష్ట లక్షణం లేదా ఆస్తి ఆధారంగా విలువలను తీసివేయడం. ఇది సంబంధిత డేటాను సౌకర్యవంతంగా యాక్సెస్ చేయడానికి మరియు అవాంఛిత నమోదులను తొలగించడానికి దారితీస్తుంది. అటువంటి పరిస్థితులలో, జావాస్క్రిప్ట్‌లోని శ్రేణి నుండి ఆబ్జెక్ట్‌ను దాని విలువతో తీసివేయడం అనేది డేటాను తక్షణమే యాక్సెస్ చేయడంలో మరియు మెమరీని సేవ్ చేయడంలో చాలా సహాయకారిగా ఉంటుంది.
ఈ కథనం జావాస్క్రిప్ట్‌లో దాని విలువ ప్రకారం శ్రేణి నుండి ఆబ్జెక్ట్‌ను తొలగించే విధానాలను చర్చిస్తుంది.
జావాస్క్రిప్ట్‌లో దాని విలువ ద్వారా అర్రే నుండి ఆబ్జెక్ట్‌ను ఎలా తీసివేయాలి/ఎలిమినేట్ చేయాలి?
జావాస్క్రిప్ట్‌లోని విలువ ప్రకారం శ్రేణి నుండి ఆబ్జెక్ట్‌ను తొలగించడానికి, క్రింది విధానాలను వర్తింపజేయండి:
పేర్కొన్న ప్రతి విధానాలను ఒక్కొక్కటిగా చర్చిద్దాం!
విధానం 1: ఫైండ్‌ఇండెక్స్() మరియు స్ప్లైస్() పద్ధతులను ఉపయోగించి జావాస్క్రిప్ట్‌లోని విలువ ద్వారా అర్రే నుండి ఒక వస్తువును తీసివేయండి
ది ' కనుగొను సూచిక() ” పద్ధతి అసలు శ్రేణికి ఎటువంటి సవరణలు చేయకుండా మూలకం యొక్క సూచిక (స్థానం)ని అందిస్తుంది. ది ' స్ప్లైస్ () ” పద్ధతి నిర్దిష్ట శ్రేణి మూలకాలను జోడిస్తుంది/తీసివేస్తుంది మరియు అసలు శ్రేణిని కూడా ప్రభావితం చేస్తుంది. తీసివేయవలసిన వస్తువు యొక్క సూచికను గుర్తించడానికి ఈ పద్ధతులను ఉపయోగించవచ్చు. ఆ తరువాత, నిర్దిష్ట వస్తువు పేర్కొన్న సంఖ్య ఆధారంగా విభజించబడింది.
వాక్యనిర్మాణం
array.findIndex ( ఫంక్ ( currVal, సూచిక, శ్రేణి ) , విలువ )ఈ వాక్యనిర్మాణంలో:
- ' ఫంక్ ”అనేది శ్రేణిలోని ప్రతి అంశానికి కాల్ చేయవలసిన ఫంక్షన్‌ను సూచిస్తుంది.
- ఫంక్షన్ పారామితులు పేర్కొన్న శ్రేణిలో ప్రస్తుత విలువ యొక్క సూచికను సూచిస్తాయి.
- ' విలువ ' ఫంక్షన్‌కు తప్పనిసరిగా పాస్ చేయవలసిన విలువను సూచిస్తుంది' ఇది ”.
శ్రేణి.స్ప్లైస్ ( సూచిక, సంఖ్య, కొత్తది )
పైన ఇచ్చిన సింటాక్స్‌లో:
- ' సూచిక ” ఐటెమ్‌లను జోడించాల్సిన లేదా తీసివేయాల్సిన స్థానానికి సూచిస్తుంది.
- ' ఒకదానిపై ” అంశం సంఖ్యను సూచిస్తుంది.
- ' కొత్త ” కొత్త మూలకాలకు ప్రత్యామ్నాయంగా అనుగుణంగా ఉంటుంది.
ఉదాహరణ
దిగువ పేర్కొన్న కోడ్‌ను అనుసరించండి:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >వీలు ఇచ్చినఅరే = [ { వయస్సు: 18 } , { వయస్సు: ఇరవై } , { వయస్సు: 25 } ] ;
వీలు removeObject = ఇచ్చినArray.findIndex ( వస్తువు = > {
తిరిగి object.age === 18 ;
} ) ;
console.log ( 'తీసివేయవలసిన వస్తువు యొక్క సూచిక:' , రిమూవ్ ఆబ్జెక్ట్ ) ;
ఇచ్చినఅరే.స్ప్లైస్ ( ఆబ్జెక్ట్ తొలగించు, 1 ) ;
console.log ( 'విలువ ద్వారా వస్తువును తీసివేసిన తర్వాత శ్రేణి అవుతుంది:' , ఇచ్చిన అర్రే ) ;
స్క్రిప్ట్ >
పై కోడ్ స్నిప్పెట్‌లో:
- పేర్కొన్న లక్షణాలను కలిగి ఉన్న వస్తువుల శ్రేణిని ప్రకటించండి.
- తదుపరి దశలో, అనుబంధించండి ' కనుగొను సూచిక() ” మునుపటి దశలో డిక్లేర్డ్ అర్రేతో పద్ధతి.
- ఇది శ్రేణిలోని ప్రతి మూలకం (వస్తువు) ద్వారా పునరావృతం చేయడానికి దారి తీస్తుంది.
- ఫలితంగా, శ్రేణి నుండి నిర్దిష్ట వస్తువు యొక్క సూచిక ప్రదర్శించబడుతుంది, అది ఆస్తికి వ్యతిరేకంగా పేర్కొన్న విలువతో సరిపోలుతుంది, అంటే, 18.
- ఆ తరువాత, వర్తించు ' స్ప్లైస్ () ” పొందబడిన ఇండెక్స్‌ను సూచించడం ద్వారా పద్ధతి, ఇది ఆ సూచికకు వ్యతిరేకంగా నిర్దిష్ట వస్తువును తీసివేస్తుంది.
- గమనించండి' 1 ” తీసివేయవలసిన వస్తువుల సంఖ్యను నిర్దేశిస్తుంది.
- చివరగా, ఫలిత వస్తువు యొక్క శ్రేణిని ప్రదర్శించండి.
అవుట్‌పుట్
పై అవుట్‌పుట్‌లో, నిర్దిష్ట వస్తువు యొక్క సూచిక ప్రదర్శించబడిందని మరియు అది తర్వాత తీసివేయబడిందని చూడవచ్చు.
విధానం 2: ఫిల్టర్() పద్ధతిని ఉపయోగించి జావాస్క్రిప్ట్‌లోని విలువ ద్వారా అర్రే నుండి ఒక వస్తువును తీసివేయండి
ది ' ఫిల్టర్ () ” పద్ధతి నిర్దిష్ట పరీక్షలో ఉత్తీర్ణత సాధించే కొత్త అంశాల శ్రేణిని సృష్టిస్తుంది. పోలిక ఆపరేటర్ ద్వారా షరతు ఆధారంగా తీసివేయవలసిన వస్తువును ఫిల్టర్ చేయడానికి ఈ పద్ధతిని అన్వయించవచ్చు.
వాక్యనిర్మాణం
array.filter ( ఫంక్ ( విలువ ) , ఇది )ఇక్కడ:
- ' ఫంక్ ” ఫిల్టరింగ్ కోసం ఫంక్షన్‌కి దారి మళ్లించే ఫంక్షన్‌కి పాయింట్లు.
- ' విలువ ” అనేది ప్రస్తుత మూలకం విలువ.
- ' ఇది ” ఫంక్షన్‌కు పంపబడిన విలువను సూచిస్తుంది.
ఉదాహరణ
దిగువ పేర్కొన్న ఉదాహరణను స్థూలంగా చూద్దాం:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >వీలు ఇచ్చినఅరే = [ { పరిమాణం: 35 } , { పరిమాణం: 40 } , { పరిమాణం: నాలుగు ఐదు } ] ;
console.log ( 'ఇచ్చిన శ్రేణి:' , ఇచ్చిన అర్రే )
వీలు newArray = ఇచ్చినArray.filter ( వస్తువు = > {
తిరిగి వస్తువు.పరిమాణం ! == నాలుగు ఐదు ;
} ) ;
console.log ( 'విలువ ద్వారా వస్తువును తీసివేసిన తర్వాత శ్రేణి అవుతుంది:' , కొత్తఅరే ) ;
స్క్రిప్ట్ >
పైన పేర్కొన్న కోడ్ లైన్లలో ఇచ్చిన విధంగా క్రింది దశలను వర్తించండి:
- అదేవిధంగా, వస్తువుల శ్రేణిని ప్రకటించి, దానిని ప్రదర్శించండి.
- ఆ తరువాత, వర్తించు ' ఫిల్టర్ () మూలకాలను (వస్తువులు) సూచించడం ద్వారా పద్ధతి
- ఇప్పుడు, '' ద్వారా సంతృప్తి చెందిన స్థితి ఆధారంగా కొత్త శ్రేణి ఏర్పడే విధంగా అనుబంధిత శ్రేణిని ఫిల్టర్ చేయండి సమానం కాదు(!==) ” పోలిక ఆపరేటర్.
- చివరగా, ఫిల్టర్ చేసిన శ్రేణిని ప్రదర్శించండి.
అవుట్‌పుట్
ఫిల్టర్ చేయబడిన వస్తువుల యొక్క కొత్త శ్రేణి ఏర్పడిందని పై అవుట్‌పుట్ సూచిస్తుంది.
విధానం 3: పాప్() పద్ధతిని ఉపయోగించి జావాస్క్రిప్ట్‌లో దాని విలువ ద్వారా అర్రే నుండి ఒక వస్తువును తీసివేయండి
ది ' పాప్() ” పద్ధతి శ్రేణిలోని చివరి మూలకాన్ని తొలగిస్తుంది మరియు అసలు శ్రేణిని కూడా ప్రభావితం చేస్తుంది. శ్రేణి నుండి నిర్దిష్ట వస్తువును పాప్ చేయడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు మరియు తీసివేయబడిన వస్తువుతో నవీకరించబడిన శ్రేణిని సృష్టిస్తుంది.
ఉదాహరణ
దిగువ ఇవ్వబడిన ఉదాహరణ చర్చించబడిన భావనను వివరిస్తుంది:
< స్క్రిప్ట్ రకం = 'టెక్స్ట్/జావాస్క్రిప్ట్' >వీలు ఇచ్చినఅరే = [ { పేరు: 'హ్యారీ' } , { పేరు: 'డేవిడ్' } ]
వీలు newArray = ఇచ్చినArray.pop ( వస్తువు = > {
తిరిగి వస్తువు.పేరు = 'హ్యారీ'
} )
console.log ( 'విలువ ద్వారా వస్తువును తీసివేసిన తర్వాత శ్రేణి అవుతుంది:' , కొత్తఅరే ) ;
స్క్రిప్ట్ >
పై కోడ్ స్నిప్పెట్‌లో:
- అదేవిధంగా, పేర్కొన్న లక్షణాలను కలిగి ఉన్న వస్తువుల శ్రేణిని ప్రకటించండి.
- తదుపరి దశలో, “ని వర్తింపజేయండి పాప్() ఆస్తికి వ్యతిరేకంగా పేర్కొన్న విలువను కలిగి ఉన్న నిర్దిష్ట వస్తువును తొలగించే పద్ధతి పేరు ”.
- ఫలితంగా, ఫలిత శ్రేణిలో ఒక వస్తువు మాత్రమే మిగిలి ఉంటుంది “ newArr ”.
- చివరగా, నవీకరించబడిన వస్తువు యొక్క శ్రేణిని ప్రదర్శించండి, అనగా, newArr.
అవుట్‌పుట్
పై అవుట్‌పుట్ కోరుకున్న అవసరం నెరవేరిందని సూచిస్తుంది.
ముగింపు
ది ' కనుగొను సూచిక() 'మరియు' స్ప్లైస్ () 'పద్ధతులు,' ఫిల్టర్ () 'పద్ధతి, లేదా' పాప్() ” జావాస్క్రిప్ట్‌లోని విలువను బట్టి శ్రేణి నుండి ఆబ్జెక్ట్‌ను తీసివేయడానికి పద్ధతిని అన్వయించవచ్చు. ఈ విధానాలు ఇండెక్సింగ్ ఆధారంగా నిర్దిష్ట వస్తువును తీసివేస్తాయి, సమానం కాని (!==) ఆపరేటర్ ద్వారా ఫిల్టర్ చేస్తాయి లేదా వరుసగా షరతుపై పాప్ చేస్తాయి. ఈ కథనం జావాస్క్రిప్ట్‌ని ఉపయోగించి శ్రేణి నుండి ఆబ్జెక్ట్‌ను దాని విలువ ద్వారా తొలగించే/తొలగించే విధానాలను వివరించింది.