ഒരു ഡവലപ്പർക്ക് ടാസ്ക്കുകൾ പൂർത്തിയാക്കാൻ മാത്രമല്ല, കൂടുതൽ കാര്യക്ഷമമായ രീതിയിൽ ടാസ്ക്കുകൾ ചെയ്യാനും ഇത് ആവശ്യമാണ്. ഡെവലപ്പർമാർക്ക് വേരിയബിളുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് എളുപ്പമാക്കുന്ന നിരവധി ലൈബ്രറികൾ ജാവാസ്ക്രിപ്റ്റിൽ ഇന്ന് ലഭ്യമാണ്. ഈ ട്യൂട്ടോറിയലിൽ Lodash ലൈബ്രറിയുടെ ഏറ്റവും സാധാരണമായ പ്രവർത്തനങ്ങൾ എങ്ങനെ പ്രയോജനപ്പെടുത്താമെന്ന് നമ്മൾ പഠിക്കും.
നിങ്ങൾ ഇതുവരെ Lodash പരീക്ഷിച്ചിട്ടില്ലെങ്കിൽ, ഇപ്പോൾ നിമിഷമാണ്. അറേകൾ, പൂർണ്ണസംഖ്യകൾ, ഒബ്ജക്റ്റുകൾ, ടെക്സ്റ്റുകൾ, മറ്റ് ഡാറ്റാ തരങ്ങൾ എന്നിവയ്ക്കൊപ്പം പ്രവർത്തിക്കുന്നത് എളുപ്പമാക്കുന്ന ഒരു സമകാലിക JavaScript യൂട്ടിലിറ്റി പാക്കേജാണ് Lodash.
വിവിധ തരത്തിലുള്ള ഒബ്ജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിന് ഇത് നിങ്ങളെ സഹായിക്കുകയും ജനറിക് രീതികൾ കോഡ് ചെയ്യേണ്ടതിന്റെ ആവശ്യകത ഇല്ലാതാക്കി നിങ്ങളുടെ സമയം ലാഭിക്കുകയും ചെയ്യും. നിങ്ങളുടെ കോഡ് കുറച്ച് ലൈനുകളോടെ കൂടുതൽ വൃത്തിയുള്ളതും എല്ലാ ബ്രൗസറുകളിലും പ്രവർത്തിക്കുകയും ചെയ്യും. നിങ്ങൾ ഇത് ഇതിനകം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾ അത് ശ്രദ്ധാപൂർവ്വം പരിഗണിക്കണം.
Lodash സ്വീകരിക്കാത്തത് ഞങ്ങളുടെ JavaScript കോഡ്ബേസുകൾക്ക് വലിയ നഷ്ടമാണ്. ജോലിസ്ഥലത്ത് നമുക്കുള്ള പൊതുവായ വെല്ലുവിളികൾക്കുള്ള ബഗ് രഹിതവും ഗംഭീരവുമായ പരിഹാരമാണിത്, ഇത് ഉപയോഗിക്കുന്നത് ഞങ്ങളുടെ കോഡ് കൂടുതൽ വായിക്കാവുന്നതും കൈകാര്യം ചെയ്യാവുന്നതുമാക്കും.
നമുക്ക് കൂടുതൽ ജനപ്രിയമായ (അല്ലെങ്കിൽ അല്ലെങ്കിലും!) Lodash ഫംഗ്ഷനുകൾ പരിശോധിച്ച് ഈ ലൈബ്രറി എത്രത്തോളം ഉപയോഗപ്രദവും മനോഹരവുമാണെന്ന് കണ്ടെത്താം.
1. _.sortedUniq
എല്ലാ തനിപ്പകർപ്പ് മൂല്യങ്ങളും ഇതിനൊപ്പം നൽകില്ല. ഇത് ക്രമീകരിച്ച അറേകൾക്ക് മാത്രമായതിനാൽ, ഇത് പ്രധാനമായും വേഗത കാരണങ്ങളാലാണ് ഉപയോഗിക്കുന്നത്. നിങ്ങൾ ഒരു വലിയ അറേയുമായി ഇടപെടുകയാണെങ്കിൽ മാത്രമേ ഇത് ഉപയോഗപ്രദമാകൂ. നിങ്ങൾക്ക് വേഗത മെച്ചപ്പെടുത്തണമെങ്കിൽ, നിങ്ങളുടെ അറേ അടുക്കുകയും അടുക്കിയ അറേകൾ ഉപയോഗിച്ച് മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്ന രീതികൾ ഉപയോഗിക്കുകയും ചെയ്യുക.
Lodash-ന് ഇതിന് സമാനമായ നിരവധി പ്രവർത്തനങ്ങൾ ഉണ്ട്. നിങ്ങൾക്ക് .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy, .sortedUniqBy, .sortedUniqBy, .sortedUniqBy
2. _.കുറയ്ക്കുക
_.കുറയ്ക്കുക എന്നത് ഒരു ഫിൽട്ടർ ഫംഗ്ഷന് സമാനമാണ്. തിരിച്ചുവന്ന ഒബ്ജക്റ്റിന്റെ ഫോം തിരഞ്ഞെടുക്കാനുള്ള ഓപ്ഷൻ നിങ്ങൾക്കുണ്ട് എന്നതാണ് വ്യത്യാസം. ഞാൻ പറയുന്നത് നിങ്ങൾക്ക് മനസ്സിലാകുന്നില്ലെങ്കിൽ ഇത് സാധാരണമാണ്; അതിനൊരു ഉദാഹരണമുണ്ട്.
സാരാംശത്തിൽ, പ്രായത്തിനനുസരിച്ച് തരംതിരിച്ച ഉപയോക്താക്കളെ ഉൾക്കൊള്ളുന്ന ഒരു പുതിയ ഒബ്ജക്റ്റ് ഞങ്ങൾ തിരികെ നൽകുന്നു, എന്നാൽ 18 മുതൽ 59 വരെ പ്രായമുള്ളവർക്ക് മാത്രം. ഈ Lodash സഹായി ഫംഗ്ഷൻ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ഒന്നാണ്. ഇത് ES6-ലും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. രണ്ട് സാധാരണ അബദ്ധങ്ങൾ ചൂണ്ടിക്കാണിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു: ഫംഗ്ഷന്റെ സമാപനത്തിൽ ഫലം തിരികെ നൽകാൻ ഓർമ്മിക്കുക, കൂടാതെ ഫലത്തിന്റെ സ്ഥിരസ്ഥിതി മൂല്യം മൂന്നാമത്തെ പാരാമീറ്ററായി നൽകുക (ഇവിടെ).
3. _.ഗെറ്റ് ആൻഡ് ._സെറ്റ്
ഇതിനായി, ഏതാണ്ട് ഒരേ കാര്യം ചെയ്യുന്ന രണ്ട് ഫംഗ്ഷനുകൾ കാണിച്ചുകൊണ്ട് ഞാൻ നിങ്ങളെ ഒരു പരിധിവരെ കബളിപ്പിക്കും. _.ഒരു ഒബ്ജക്റ്റിൽ നിന്ന് ഒരു പ്രോപ്പർട്ടി മൂല്യം റിട്ടേൺ ചെയ്യുക, കൂടാതെ _.സെറ്റ് ചെയ്യുക, നിങ്ങൾ ഊഹിച്ചു, മൂല്യമുള്ള ഒരു പ്രോപ്പർട്ടി സജ്ജീകരിക്കുക. ഒരു പ്രോപ്പർട്ടി അതിന്റെ പാതയിലൂടെ നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാം എന്നതൊഴിച്ചാൽ അദ്വിതീയമായ ഒന്നുമില്ല.
നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം.
_.set എന്ന് വിളിക്കുമ്പോൾ പാത്ത് നിലവിലില്ലെങ്കിൽ, അത് ജനറേറ്റ് ചെയ്യപ്പെടും. “നിർവചിക്കാത്ത പ്രോപ്പർട്ടി 'ഇനങ്ങൾ' സജ്ജീകരിക്കാൻ കഴിയില്ല” പിശകുകൾ ഇനി ഉണ്ടാകില്ല. പാത നിലവിലില്ലെങ്കിൽ, ഒരു പിശകിന് പകരം _.get നിർവചിക്കാതെ തിരികെ വരും. പാത്ത് നിർവചിക്കാതെ പരിഹരിക്കപ്പെടുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ഡിഫോൾട്ട് മൂല്യവും നൽകാം (മൂന്നാം പാരാമീറ്റർ).
4. _.കണ്ടെത്തുക
ഒരൊറ്റ ഒബ്ജക്റ്റ് കണ്ടെത്തുന്നതിന് ഒരു അറേയിലൂടെ ലൂപ്പ് ചെയ്യുന്നതിന് പകരം, നമുക്ക് _.find ഉപയോഗിക്കാം. അത് നല്ലതാണ്, പക്ഷേ അത് മാത്രമല്ല _.കണ്ടെത്താൻ കഴിയുന്നത്. ഒരൊറ്റ വരി കോഡ് ഉപയോഗിച്ച്, നിരവധി പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഒബ്ജക്റ്റ് കണ്ടെത്താനും കഴിയും. ഇത് പരിശോധിക്കുക!
5. _.കീബൈ
എന്റെ പ്രിയപ്പെട്ടവയിൽ ഒന്നാണ് _.keyBy. ഒരു നിശ്ചിത ആട്രിബ്യൂട്ടുള്ള ഒരു വസ്തു നേടാൻ ശ്രമിക്കുമ്പോൾ ഇത് വളരെ ഉപയോഗപ്രദമാണ്. ഞങ്ങൾക്ക് 100 ബ്ലോഗ് എൻട്രികൾ ഉണ്ടെന്നും "34abc" എന്ന ഐഡി ഉള്ളത് പിടിക്കാൻ ആഗ്രഹിക്കുന്നുവെന്നും കരുതുക. ഞങ്ങൾ അത് എങ്ങനെ ചെയ്യാൻ പോകുന്നു? എന്താണ് സംഭവിക്കുന്നതെന്ന് നമുക്ക് നോക്കാം! ഒരു സെർവർ അത് ഒരു അറേ ആയി നൽകിയാൽ ഒരു ഒബ്ജക്റ്റ് ശേഖരം ക്രമീകരിക്കാൻ ഈ രീതി നിങ്ങളെ സഹായിക്കും. ഒരു ഫംഗ്ഷൻ രണ്ടാമത്തെ ആർഗ്യുമെന്റായി ഉപയോഗിക്കാം.
6. _.ഓരോന്നിനും
ഈ രീതി ഒബ്ജക്റ്റുകളുടെ ഒരു നിരയെ ഒന്നൊന്നായി ആവർത്തിക്കും, നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഏത് യുക്തിയും ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഈ ആദ്യ ഉദാഹരണത്തിൽ, ഞാൻ ഉപയോക്തൃ ഒബ്ജക്റ്റുകളുടെ ഒരു ലിസ്റ്റ് ലൂപ്പ് ചെയ്യും, അവയുടെ പേരുകളും പേരുകളും സംയോജിപ്പിച്ച് ഫുൾ നെയിം എന്ന പുതിയ പ്രോപ്പർട്ടി സൃഷ്ടിക്കും.
ഇവയിൽ ഓരോന്നും രണ്ട് പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്നു. നമ്മൾ ലൂപ്പ് ചെയ്യുന്ന അറേ ആദ്യ പാരാമീറ്ററാണ്. രണ്ടാമത്തെ ആർഗ്യുമെന്റ് ഒരു ഇറ്ററേറ്റ് ഫംഗ്ഷനാണ്, ആദ്യ പാരാമീറ്റർ വ്യക്തിഗത ഇനത്തിന്റെ റഫറൻസും രണ്ടാമത്തേത് ആവർത്തനത്തിന്റെ നിലവിലെ സൂചികയുമാണ്.
7. _.മാപ്പ്
മാപ്പ്, ഓരോന്നിനും പോലെ, മൂല്യങ്ങളുടെ ഒരു നിരയിലുടനീളം ആവർത്തിക്കുന്നു. മാപ്പ് ഫംഗ്ഷൻ, മറുവശത്ത്, ഐറ്ററേറ്റ് ഫംഗ്ഷൻ നൽകുന്ന മൂല്യങ്ങളുടെ ഒരു പുതിയ ശ്രേണി നൽകുന്നു. ഇവിടെ ഓരോ ഉദാഹരണത്തിലും ഉള്ള അതേ ഉപയോക്താക്കളുടെ ശേഖരം ഞങ്ങൾ ഉപയോഗിക്കുന്നു. എല്ലാ ഉപയോക്താക്കളുടെയും പൂർണ്ണമായ പേരുകളുടെ ഒരു പരന്ന അറേ ഉള്ള ഒരു പുതിയ വേരിയബിൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ _.map ഉപയോഗിച്ചേക്കാം.
8. _.വ്യത്യാസം
ഡിഫറൻസ് ഫംഗ്ഷൻ ആദ്യത്തെയും രണ്ടാമത്തെയും അറേകൾക്കിടയിൽ വ്യത്യാസമുള്ള മൂല്യങ്ങളുടെ ഒരു പുതിയ ശ്രേണി സൃഷ്ടിക്കും. വാദങ്ങളുടെ സ്ഥാനങ്ങൾ ഫലങ്ങളെ ബാധിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.
9. _. നേടുക
ഒരു ഒബ്ജക്റ്റിനുള്ളിൽ ഒരു ഘടകം കണ്ടെത്തുന്നതിന് _.get() ഫംഗ്ഷന് നമ്മെ സഹായിക്കും. വിതരണം ചെയ്ത പാതയിൽ ഒരു ഘടകം കണ്ടെത്തിയില്ലെങ്കിൽ, തിരികെ ലഭിക്കുന്നതിന് _.get() ഫംഗ്ഷനായി നമുക്ക് സ്ഥിരസ്ഥിതി മൂല്യം സജ്ജമാക്കാൻ കഴിയും. _.get() ഫംഗ്ഷൻ മൂന്ന് പാരാമീറ്ററുകൾ എടുക്കുന്നു, അതിൽ ആദ്യത്തേത് ഒരു ഘടകം ലഭിക്കാൻ ആഗ്രഹിക്കുന്ന ഒബ്ജക്റ്റാണ്. പാത രണ്ടാമത്തേതാണ്. ഒരു ഘടകം കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ, ഞങ്ങൾ തിരികെ നൽകാൻ ആഗ്രഹിക്കുന്ന ഡിഫോൾട്ട് മൂല്യമാണ് മൂന്നാമത്തെ മൂല്യം.
10. _.കണ്ടെത്തുക
_find() ഫംഗ്ഷൻ _.get() രീതിക്ക് സമാനമായി കാണപ്പെടാം. _.get() രീതി പോലെ _.find() ഫംഗ്ഷൻ മൂന്ന് പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്നു. എന്നിരുന്നാലും, _.get() രീതിയിൽ നിന്ന് വ്യത്യസ്തമായി, ആദ്യത്തെ ആർഗ്യുമെന്റ് ഒരു അറേയോ ഒബ്ജക്റ്റോ ആകാം. രണ്ടാമത്തെ ആർഗ്യുമെന്റ് ഓരോ ആവർത്തനത്തിലും വിളിക്കപ്പെടുന്ന ഫംഗ്ഷൻ വ്യക്തമാക്കുന്നു. മൂന്നാമത്തെ ഇൻപുട്ട് ശേഖരത്തിന്റെ ആരംഭ സൂചികയാണ്. കാരണം _.find() ഫംഗ്ഷൻ ഒരു ശേഖരത്തിലെ ഓരോ ഘടകത്തിലും ആവർത്തിക്കുന്നു.
11. _.groupBy
ഒരു ഫംഗ്ഷന്റെ (അല്ലെങ്കിൽ ക്രമരഹിതമായി തിരഞ്ഞെടുത്ത പ്രോപ്പർട്ടി നാമം) ഫലമനുസരിച്ച് ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുക, ഓരോ മൂല്യവും ഒരേ കീ ഉള്ള ഒബ്ജക്റ്റുകളുടെ ഒരു നിരയാണ്.
12. _.സെറ്റ്
രീതി _.set() എന്നത് _.get() എന്ന രീതിയുടെ വിപരീതമാണ്. ഒരു നിശ്ചിത പാതയിലെ മൂലകത്തിന്റെ മൂല്യം ഇത് മാറ്റും. ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ അറേ ആദ്യ പാരാമീറ്ററാണ്, പാത രണ്ടാമത്തേതാണ്, നിങ്ങൾ സജ്ജീകരിക്കാൻ ആഗ്രഹിക്കുന്ന മൂല്യം മൂന്നാമത്തേതാണ്.
13. _.ലയിപ്പിക്കുക
ഇത് Object.assign എന്നതിന് സമാനമായി പ്രവർത്തിക്കുന്നു, അല്ലാതെ ആഴത്തിലുള്ള ഒബ്ജക്റ്റുകൾ മാറ്റിസ്ഥാപിക്കുന്നതിനുപകരം അവ അപ്ഡേറ്റ് ചെയ്യുന്നതിനായി അടിവരയിട്ട ഘടനയിലേക്ക് ആഴത്തിൽ ആവർത്തിക്കുന്നു.
14. ._deburr
ഇത് തികച്ചും നേരായ ഉദാഹരണമാണ്. എല്ലാ "സംയോജന ഡയക്രിറ്റിക്കൽ അടയാളങ്ങളും" നീക്കം ചെയ്തു. അങ്ങനെ "ഇ" "ഇ" ആയി മാറുന്നു. അന്തർദേശീയവൽക്കരണവും പ്രാദേശികവൽക്കരണവും ഉള്ളപ്പോൾ, തിരയൽ ഫംഗ്ഷനുകൾക്കായി ടെക്സ്റ്റ് ഡീബർ ചെയ്യുന്നത് നല്ല രീതിയാണ്.
15. _.ഡീബൗൺസ്
ഇത് ഏറ്റവും ഫലപ്രദമായ Lodash തന്ത്രങ്ങളിൽ ഒന്നാണ്. അത് എന്തുചെയ്യുന്നുവെന്നും എപ്പോൾ ഉപയോഗിക്കണമെന്നും മനസ്സിലാക്കാനും ബുദ്ധിമുട്ടായേക്കാം. _.debounce() രീതി ഒരു ഫംഗ്ഷൻ നൽകുന്നു. _.debounce() രീതിയുടെ ഫംഗ്ഷൻ, ഫംഗ്ഷൻ അവസാനമായി അഭ്യർത്ഥിച്ചതിന് ശേഷം ഒരു നിശ്ചിത എണ്ണം മില്ലിസെക്കൻഡ് കടന്നുപോകുന്നതുവരെ അഭ്യർത്ഥന വൈകിപ്പിക്കും.
തീരുമാനം
JavaScript ഭാഷയുടെ ശക്തമായ ഒരു വിപുലീകരണമാണ് Lodash. കുറഞ്ഞ പ്രയത്നത്തിലൂടെ, ഒരാൾക്ക് സംക്ഷിപ്തവും കാര്യക്ഷമവുമായ കോഡ് നിർമ്മിക്കാം. ലോഡാഷും പൂർണ്ണമായും മോഡുലാർ ആണ്. അതിന്റെ ചില പ്രവർത്തനങ്ങൾ ആത്യന്തികമായി ഒഴിവാക്കപ്പെടുമെങ്കിലും, JS ഭാഷയുടെ പരിണാമത്തിന് കാരണമാകുമ്പോൾ തന്നെ ഇത് ഡെവലപ്പർമാർക്ക് നിരവധി ആനുകൂല്യങ്ങൾ നൽകുമെന്ന് ഞാൻ വിശ്വസിക്കുന്നു.
അറേകൾ, ഒബ്ജക്റ്റുകൾ, ശേഖരങ്ങൾ എന്നിവയ്ക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ Lodash എത്രത്തോളം ശക്തമാകുമെന്ന് കാണാൻ ഈ കുറച്ച് Lodash കഴിവുകൾ നിങ്ങളെ സഹായിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നിങ്ങൾക്ക് സന്ദർശിക്കാം ഡോക്യുമെന്റേഷൻ അത് വാഗ്ദാനം ചെയ്യുന്ന മറ്റ് നിരവധി ഓപ്ഷനുകൾ പര്യവേക്ഷണം ചെയ്യാൻ.
നിങ്ങളുടെ അഭിപ്രായങ്ങൾ രേഖപ്പെടുത്തുക