డెవలపర్కు టాస్క్లను పూర్తి చేయడం మాత్రమే అవసరం లేదు, అయితే టాస్క్లను మరింత సమర్థవంతంగా చేయడం కూడా అవసరం. డెవలపర్లకు వేరియబుల్స్తో పని చేయడం సులభతరం చేసే అనేక లైబ్రరీలు ఈ రోజు JavaScriptలో అందుబాటులో ఉన్నాయి. మేము ఈ ట్యుటోరియల్లో Lodash లైబ్రరీ యొక్క అత్యంత సాధారణ ఫంక్షన్లను ఎలా ఉపయోగించాలో నేర్చుకుంటాము.
మీరు ఇంకా Lodashని ప్రయత్నించకుంటే, ఇప్పుడు ఆ క్షణం. Lodash అనేది సమకాలీన జావాస్క్రిప్ట్ యుటిలిటీ ప్యాకేజీ, ఇది శ్రేణులు, పూర్ణాంకాలు, వస్తువులు, టెక్స్ట్లు మరియు ఇతర డేటా రకాలతో పని చేయడం సులభతరం చేస్తుంది.
ఇది వివిధ రకాల వస్తువులతో వ్యవహరించడంలో మీకు సహాయం చేస్తుంది మరియు సాధారణ పద్ధతులను కోడ్ చేయవలసిన అవసరాన్ని తొలగించడం ద్వారా మీ సమయాన్ని ఆదా చేస్తుంది. మీ కోడ్ తక్కువ లైన్లతో శుభ్రంగా ఉంటుంది మరియు అన్ని బ్రౌజర్లలో పని చేస్తుంది. మీరు దీన్ని ఇప్పటికే ఉపయోగించకపోతే, మీరు దానిని జాగ్రత్తగా పరిశీలించాలి.
Lodashని స్వీకరించకపోవడం మా JavaScript కోడ్బేస్లకు భారీ నష్టం. పనిలో మనకు ఎదురయ్యే సాధారణ సవాళ్లకు ఇది బగ్-రహిత మరియు సొగసైన పరిష్కారం, మరియు దీన్ని ఉపయోగించడం ద్వారా మా కోడ్ను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేస్తుంది.
మరింత జనాదరణ పొందిన (లేదా!) Lodash ఫంక్షన్లలో కొన్నింటిని పరిశోధిద్దాం మరియు ఈ లైబ్రరీ ఎంత ఉపయోగకరంగా మరియు అందంగా ఉందో తెలుసుకుందాం.
1. _.sortedUniq
అన్ని నకిలీ విలువలు దీనితో అందించబడవు. ఎందుకంటే ఇది క్రమబద్ధీకరించబడిన శ్రేణుల కోసం, ఇది ప్రధానంగా వేగ కారణాల కోసం ఉపయోగించబడుతుంది. మీరు పెద్ద శ్రేణితో వ్యవహరిస్తున్నప్పుడు మాత్రమే ఇది ఉపయోగపడుతుంది. మీరు వేగాన్ని మెరుగుపరచాలనుకుంటే, మీ శ్రేణిని క్రమబద్ధీకరించండి మరియు క్రమబద్ధీకరించబడిన శ్రేణులతో మెరుగ్గా పనిచేసే పద్ధతులను ఉపయోగించండి.
Lodash ఇలాంటి అనేక ఇతర విధులను కలిగి ఉంది. మీరు .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy, .sortedUniqBy, .sortedUniqBy
2. _.తగ్గించు
_.రెడ్యూస్ అనేది ఫిల్టర్ ఫంక్షన్ని పోలి ఉంటుంది. ఒకే తేడా ఏమిటంటే, మీరు తిరిగి వచ్చిన వస్తువు యొక్క రూపాన్ని ఎంచుకునే ఎంపికను కలిగి ఉంటారు. ఇది సాధారణం, నేను చెప్పేది మీరు అర్థం చేసుకోకపోతే; దానికి ఒక ఉదాహరణ ఉంది.
సారాంశంలో, మేము వయస్సు ఆధారంగా వర్గీకరించబడిన వినియోగదారులను కలిగి ఉన్న కొత్త ఆబ్జెక్ట్ను తిరిగి అందిస్తాము, కానీ 18 నుండి 59 సంవత్సరాల వయస్సు గల వారికి మాత్రమే. ఈ Lodash సహాయక ఫంక్షన్ సాధారణంగా ఉపయోగించే వాటిలో ఒకటి. ఇది ES6లో కూడా చేర్చబడింది. నేను రెండు విలక్షణమైన తప్పులను కూడా ఎత్తి చూపాలనుకుంటున్నాను: ఫంక్షన్ ముగింపులో ఫలితాన్ని అందించాలని గుర్తుంచుకోండి మరియు ఫలితం కోసం డిఫాల్ట్ విలువను మూడవ పరామితి (ఇక్కడ)గా అందించండి.
3. _.గెట్ అండ్ ._సెట్
దీని కోసం, దాదాపు ఒకే పనిని చేసే రెండు ఫంక్షన్లను చూపడం ద్వారా నేను మిమ్మల్ని కొంత మోసం చేస్తాను. _.ఒక వస్తువు నుండి ఆస్తి విలువను పొందండి మరియు _.సెట్ చేయండి, మీరు ఊహిస్తున్నట్లుగా విలువతో ఆస్తిని సెట్ చేయండి. మీరు ప్రాపర్టీని దాని మార్గం ద్వారా యాక్సెస్ చేయడం తప్ప, ప్రత్యేకమైనది ఏమీ లేదు.
ఒక ఉదాహరణ చూద్దాం.
_.సెట్కి కాల్ చేస్తున్నప్పుడు మార్గం ఉనికిలో లేకుంటే, అది జనరేట్ చేయబడుతుంది. "నిర్వచించబడని ఆస్తి 'ఐటెమ్లను' సెట్ చేయడం సాధ్యం కాదు" లోపాలు ఏవీ ఉండవు. మార్గం ఉనికిలో లేకుంటే, _.get ఎర్రర్కు బదులుగా నిర్వచించబడకుండా తిరిగి వస్తుంది. మార్గం నిర్వచించబడనిదిగా పరిష్కరిస్తే, మీరు డిఫాల్ట్ విలువను కూడా అందించవచ్చు (మూడవ పరామితి).
4. _.కనుగొనండి
ఒకే వస్తువును కనుగొనడానికి శ్రేణి ద్వారా లూప్ చేయడానికి బదులుగా, మేము _.findని ఉపయోగించవచ్చు. అది మంచిది, కానీ అది ఒక్కటే కాదు _.ఫైండ్ చేయగలదు. ఒకే లైన్ కోడ్తో, మీరు అనేక లక్షణాలను ఉపయోగించడం ద్వారా వస్తువును కూడా కనుగొనవచ్చు. దీన్ని తనిఖీ చేయండి!
5. _.కీబై
నాకు ఇష్టమైన వాటిలో ఒకటి _.keyBy. ఒక నిర్దిష్ట లక్షణంతో వస్తువును పొందేందుకు ప్రయత్నించినప్పుడు ఇది చాలా ఉపయోగకరంగా ఉంటుంది. మేము 100 బ్లాగ్ ఎంట్రీలను కలిగి ఉన్నామని మరియు "34abc" ఐడితో ఉన్నదాన్ని పొందాలనుకుంటున్నాము. మేము దీన్ని ఎలా చేయబోతున్నాం? చూద్దాం ఏం జరుగుతుందో! సర్వర్ దానిని శ్రేణిగా అందిస్తే ఆబ్జెక్ట్ సేకరణను ఏర్పాటు చేయడంలో ఈ పద్ధతి మీకు సహాయపడుతుంది. ఒక ఫంక్షన్ను రెండవ ఆర్గ్యుమెంట్గా కూడా ఉపయోగించవచ్చు.
6. _.ఒక్కొక్కరికి
ఈ పద్ధతి వస్తువుల శ్రేణిని ఒక్కొక్కటిగా పునరావృతం చేస్తుంది, మీకు కావలసిన తర్కాన్ని చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఈ మొదటి ఉదాహరణలో, నేను యూజర్ ఆబ్జెక్ట్ల జాబితాను లూప్ చేస్తాను, పూర్తి పేరు అనే కొత్త ప్రాపర్టీని సృష్టించడానికి వారి మొదటి మరియు చివరి పేర్లను విలీనం చేస్తాను.
వీటిలో ప్రతి ఒక్కటి రెండు పారామితులను అంగీకరిస్తుంది. మేము లూప్ చేస్తున్న శ్రేణి మొదటి పరామితి. రెండవ ఆర్గ్యుమెంట్ ఒక ఇటరేట్ ఫంక్షన్, మొదటి పరామితి వ్యక్తిగత అంశం సూచన మరియు రెండవది పునరావృతం యొక్క ప్రస్తుత సూచిక.
7. _.మ్యాప్
మ్యాప్, ప్రతి దాని వలె, విలువల శ్రేణిలో పునరావృతమవుతుంది. మ్యాప్ ఫంక్షన్, మరోవైపు, ఇటరేట్ ఫంక్షన్ ద్వారా అందించబడిన విలువల యొక్క కొత్త శ్రేణిని అందిస్తుంది. మేము ఇక్కడ మా forEach ఉదాహరణలో ఉన్న అదే వినియోగదారుల సేకరణను ఉపయోగిస్తున్నాము. వినియోగదారుల పూర్తి పేర్లతో కూడిన చదునైన శ్రేణిని కలిగి ఉన్న కొత్త వేరియబుల్ని రూపొందించడానికి మేము _.mapని ఉపయోగించవచ్చు.
8. _.తేడా
తేడా ఫంక్షన్ మొదటి మరియు రెండవ శ్రేణుల మధ్య విభిన్నమైన విలువల యొక్క కొత్త శ్రేణిని ఉత్పత్తి చేస్తుంది. వాదనల స్థానాలు ఫలితాలను ప్రభావితం చేస్తాయని గమనించడం చాలా ముఖ్యం.
9. _.పొందండి
_.get() ఫంక్షన్ ఒక వస్తువులోని మూలకాన్ని గుర్తించడంలో మాకు సహాయపడుతుంది. సరఫరా చేయబడిన మార్గంలో మూలకం కనుగొనబడకపోతే, మేము _.get() ఫంక్షన్ కోసం డిఫాల్ట్ విలువను సెట్ చేయవచ్చు. _.get() ఫంక్షన్ మూడు పారామితులను తీసుకుంటుంది, అందులో మొదటిది మనం ఒక మూలకాన్ని పొందాలనుకుంటున్న వస్తువు. మార్గం రెండవది. మూడవ విలువ అనేది మూలకం గుర్తించబడకపోతే మనం తిరిగి ఇవ్వాలనుకుంటున్న డిఫాల్ట్ విలువ.
10. _.కనుగొనండి
_find() ఫంక్షన్ _.get() పద్ధతికి సమానంగా కనిపించవచ్చు. _.find() ఫంక్షన్, _.get() పద్ధతి వలె, మూడు పారామితులను అంగీకరిస్తుంది. అయినప్పటికీ, _.get() పద్ధతి వలె కాకుండా, మొదటి వాదన శ్రేణి లేదా ఆబ్జెక్ట్ కావచ్చు. రెండవ ఆర్గ్యుమెంట్ ప్రతి పునరావృతంలో పిలవబడే ఫంక్షన్ను నిర్దేశిస్తుంది. మూడవ ఇన్పుట్ సేకరణ ప్రారంభ సూచిక. ఎందుకంటే _.find() ఫంక్షన్ సేకరణలోని ప్రతి మూలకంపై పునరావృతమవుతుంది.
11. _.groupBy
ఒక ఫంక్షన్ (లేదా యాదృచ్ఛికంగా ఎంచుకున్న ఆస్తి పేరు) ఫలితంగా పేరు పెట్టబడిన వస్తువును సృష్టించండి, ప్రతి విలువ ఒకే కీతో ఉన్న వస్తువుల శ్రేణిగా ఉంటుంది.
12. _.సెట్
పద్ధతి _.set() అనేది _.get() పద్ధతికి విలోమం. ఇది ఇచ్చిన మార్గంలో మూలకం యొక్క విలువను మారుస్తుంది. వస్తువు లేదా శ్రేణి మొదటి పరామితి, మార్గం రెండవది మరియు మీరు సెట్ చేయాలనుకుంటున్న విలువ మూడవది.
13. _.విలీనం
ఇది Object.assign వలె పనిచేస్తుంది, ఇది లోతైన వస్తువులను భర్తీ చేయడానికి బదులుగా వాటిని అప్డేట్ చేయడానికి అంతర్లీన నిర్మాణంలోకి లోతుగా పునరావృతమవుతుంది.
14. ._డెబర్
ఇది చాలా సరళమైన ఉదాహరణ. అన్ని "కలిపే డయాక్రిటికల్ గుర్తులు" తీసివేయబడతాయి. కాబట్టి “é” “e” అవుతుంది. అంతర్జాతీయీకరణ మరియు స్థానికీకరణ ఉన్నప్పుడు, శోధన ఫంక్షన్ల కోసం వచనాన్ని డీబర్ చేయడం మంచి పద్ధతి.
15. _.డీబౌన్స్
ఇది అత్యంత ప్రభావవంతమైన లోడాష్ వ్యూహాలలో ఒకటి. ఇది ఏమి చేస్తుందో మరియు మీరు ఎప్పుడు ఉపయోగించాలో గ్రహించడం కూడా కష్టంగా ఉండవచ్చు. _.debounce() పద్ధతి ఒక ఫంక్షన్ని అందిస్తుంది. _.debounce() మెథడ్ ఫంక్షన్ చివరిగా ఫంక్షన్ ప్రారంభించబడినప్పటి నుండి నిర్దిష్ట సంఖ్యలో మిల్లీసెకన్లు గడిచే వరకు ఆహ్వానాన్ని ఆలస్యం చేస్తుంది.
ముగింపు
Lodash అనేది JavaScript భాష యొక్క శక్తివంతమైన పొడిగింపు. తక్కువ ప్రయత్నంతో, ఒకరు క్లుప్తమైన మరియు సమర్థవంతమైన కోడ్ను రూపొందించవచ్చు. Lodash కూడా పూర్తిగా మాడ్యులర్. దాని యొక్క కొన్ని కార్యాచరణలు అంతిమంగా నిలిపివేయబడినప్పటికీ, JS భాష యొక్క పరిణామాన్ని కూడా ఇది డ్రైవింగ్ చేస్తూనే డెవలపర్లకు అనేక ప్రయోజనాలను అందిస్తుందని నేను నమ్ముతున్నాను.
శ్రేణులు, వస్తువులు మరియు సేకరణలతో పని చేస్తున్నప్పుడు Lodash ఎంత శక్తివంతమైనదో చూడడానికి ఈ కొన్ని Lodash సామర్థ్యాలు మీకు సహాయపడతాయని నేను ఆశిస్తున్నాను. మీరు సందర్శించవచ్చు డాక్యుమెంటేషన్ ఇది అందించే అనేక ఇతర ఎంపికలను అన్వేషించడానికి.
సమాధానం ఇవ్వూ