વિકાસકર્તા માટે માત્ર કાર્યો પૂર્ણ કરવા માટે જરૂરી નથી, પરંતુ તે વધુ કાર્યક્ષમ રીતે કાર્યો કરવા માટે પણ જરૂરી છે. આજે JavaScript માં ઘણી લાઇબ્રેરીઓ ઉપલબ્ધ છે જે વિકાસકર્તાઓ માટે વેરીએબલ સાથે કામ કરવાનું સરળ બનાવે છે. આપણે આ ટ્યુટોરીયલમાં લોડાશ લાઇબ્રેરીના સૌથી સામાન્ય કાર્યોનો ઉપયોગ કેવી રીતે કરવો તે શીખીશું.
જો તમે હજી સુધી લોડાશનો પ્રયાસ કર્યો નથી, તો હવે તે ક્ષણ છે. લોડાશ એ સમકાલીન JavaScript ઉપયોગિતા પેકેજ છે જે એરે, પૂર્ણાંકો, ઑબ્જેક્ટ્સ, ટેક્સ્ટ્સ અને અન્ય ડેટા પ્રકારો સાથે કામ કરવાનું સરળ બનાવે છે.
તે તમને વિવિધ પ્રકારની વસ્તુઓ સાથે વ્યવહાર કરવામાં મદદ કરશે અને સામાન્ય પદ્ધતિઓને કોડ કરવાની જરૂરિયાતને દૂર કરીને તમારો સમય બચાવશે. તમારો કોડ ઓછી લીટીઓ સાથે વધુ સ્વચ્છ હશે અને તમામ બ્રાઉઝર્સમાં કાર્ય કરશે. જો તમે પહેલાથી જ તેનો ઉપયોગ કરી રહ્યાં નથી, તો તમારે તેને કાળજીપૂર્વક ધ્યાનમાં લેવું જોઈએ.
લોડાશને અપનાવવું એ આપણા JavaScript કોડબેસેસ માટે એક મોટું નુકસાન છે. તે અમારી પાસે કામ પરના સામાન્ય પડકારોનો બગ-મુક્ત અને ભવ્ય ઉકેલ છે, અને તેનો ઉપયોગ ફક્ત અમારા કોડને વધુ વાંચવા યોગ્ય અને વ્યવસ્થિત બનાવશે.
ચાલો કેટલાક વધુ લોકપ્રિય (અથવા નહીં!) લોડાશ ફંક્શન્સનો અભ્યાસ કરીએ અને જાણીએ કે આ પુસ્તકાલય કેટલું ઉપયોગી અને સુંદર છે.
1. _.સૉર્ટેડ યુનિક
બધા ડુપ્લિકેટ મૂલ્યો આ સાથે પરત કરવામાં આવશે નહીં. કારણ કે તે માત્ર સૉર્ટ કરેલ એરે માટે છે, આનો ઉપયોગ મુખ્યત્વે ઝડપના કારણોસર થાય છે. જો તમે મોટા એરે સાથે કામ કરી રહ્યાં હોવ તો જ આ ઉપયોગી છે. જો તમે ઝડપ સુધારવા માંગતા હો, તો તમારા એરેને સૉર્ટ કરો અને સૉર્ટ કરેલ એરે સાથે વધુ સારી રીતે કાર્ય કરતી પદ્ધતિઓનો ઉપયોગ કરો.
લોડાશમાં અન્ય સંખ્યાબંધ કાર્યો છે જે આના જેવા જ છે. તમે .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy, .sortedUniqBy, .sortedUniqBy, .sortedUniqBy, .sortedUniq,
2. _.ઘટાડો
_.reduce એ ફિલ્ટર ફંક્શન જેવું જ છે. માત્ર એટલો જ તફાવત છે કે તમારી પાસે પરત કરેલ ઑબ્જેક્ટનું સ્વરૂપ પસંદ કરવાનો વિકલ્પ છે. તે સામાન્ય છે, જો તમે સમજી શકતા નથી કે હું શું કહું છું; તેના માટે એક ઉદાહરણ છે.
સારમાં, અમે એક નવો ઑબ્જેક્ટ પરત કરીએ છીએ જેમાં વય દ્વારા વર્ગીકૃત કરાયેલા વપરાશકર્તાઓનો સમાવેશ થાય છે, પરંતુ માત્ર 18 થી 59 વર્ષની વયના લોકો માટે. આ Lodash હેલ્પર ફંક્શન સૌથી સામાન્ય રીતે ઉપયોગમાં લેવાતું એક છે. તે ES6 માં પણ સામેલ છે. હું બે લાક્ષણિક ભૂલો પણ દર્શાવવા માંગુ છું: ફંક્શનના નિષ્કર્ષ પર પરિણામ પરત કરવાનું યાદ રાખો, અને ત્રીજા પરિમાણ (અહીં) તરીકે પરિણામ માટે ડિફોલ્ટ મૂલ્ય સપ્લાય કરો.
3. _.મેળવો અને ._સેટ કરો
આ માટે, હું તમને બે ફંક્શન્સ બતાવીને થોડીક યુક્તિ કરીશ જે લગભગ સમાન વસ્તુ કરે છે. _.get ઑબ્જેક્ટમાંથી પ્રોપર્ટી વેલ્યુ પરત કરે છે, અને _.set, સારું, તમે અનુમાન લગાવ્યું છે, કિંમત સાથે પ્રોપર્ટી સેટ કરો. કંઈ અનન્ય નથી, સિવાય કે તમે કોઈ મિલકતને તેના પાથ દ્વારા ઍક્સેસ કરી શકો.
ચાલો એક ઉદાહરણ જોઈએ.
જો _.set ને કૉલ કરતી વખતે પાથ અસ્તિત્વમાં ન હોય, તો તે જનરેટ થશે. ત્યાં હવે "અવ્યાખ્યાયિત ન હોય તેવી મિલકત 'આઇટમ્સ' સેટ કરી શકાતી નથી" ભૂલો હશે નહીં. જો પાથ અસ્તિત્વમાં નથી, તો _.get ભૂલને બદલે અવ્યાખ્યાયિત પરત આવશે. જો પાથ અવ્યાખ્યાયિત પર ઉકેલે છે, તો તમે ડિફોલ્ટ મૂલ્ય (ત્રીજું પરિમાણ) પણ આપી શકો છો.
4. _.શોધો
એક ઑબ્જેક્ટ શોધવા માટે એરે દ્વારા લૂપ કરવાને બદલે, અમે _.find નો ઉપયોગ કરી શકીએ છીએ. તે સારું છે, પરંતુ તે એકમાત્ર વસ્તુ નથી જે શોધી શકે છે. કોડની એક લીટી સાથે, તમે અસંખ્ય ગુણધર્મોનો ઉપયોગ કરીને ઑબ્જેક્ટ પણ શોધી શકો છો. તપાસી જુઓ!
5. _.કીબાય
મારા મનપસંદમાંનું એક _.keyBy છે. ચોક્કસ વિશેષતા સાથે ઑબ્જેક્ટ મેળવવાનો પ્રયાસ કરતી વખતે તે ખૂબ ઉપયોગી છે. ધારો કે અમારી પાસે 100 બ્લોગ એન્ટ્રીઓ છે અને અમે તેને “34abc” આઈડી સાથે મેળવવા માંગીએ છીએ. અમે તે કેવી રીતે કરવા જઈ રહ્યા છીએ? ચાલો જોઈએ શું થાય છે! આ પદ્ધતિ તમને ઑબ્જેક્ટ સંગ્રહ ગોઠવવામાં મદદ કરી શકે છે જો સર્વર તેને એરે તરીકે પ્રદાન કરે છે. ફંક્શનનો ઉપયોગ બીજી દલીલ તરીકે પણ થઈ શકે છે.
6. _.દરેક માટે
આ પદ્ધતિ એક પછી એક ઑબ્જેક્ટની શ્રેણી પર પુનરાવર્તિત થશે, તમને ગમે તે તર્ક કરવા દે છે. આ પ્રથમ ઉદાહરણમાં, હું યુઝર ઑબ્જેક્ટ્સની સૂચિ પર લૂપ કરીશ, તેમના પ્રથમ અને છેલ્લા નામોને મર્જ કરીને fullName નામની નવી પ્રોપર્ટી બનાવીશ.
આમાંના દરેક બે પરિમાણો સ્વીકારે છે. આપણે જે એરે પર લૂપ કરી રહ્યા છીએ તે પ્રથમ પરિમાણ છે. બીજી દલીલ એ પુનરાવર્તિત કાર્ય છે, જેમાં પ્રથમ પરિમાણ વ્યક્તિગત આઇટમ સંદર્ભ છે અને બીજું પુનરાવૃત્તિનું વર્તમાન સૂચક છે.
7. _.નકશો
નકશો, જેમ કે forEach, મૂલ્યોની શ્રેણીમાં પુનરાવર્તિત થાય છે. બીજી બાજુ, નકશો ફંક્શન, પુનરાવર્તિત કાર્ય દ્વારા પ્રદાન કરાયેલ મૂલ્યોની નવી શ્રેણી પરત કરે છે. અમે અહીં અમારા દરેક ઉદાહરણ માટે વપરાશકર્તાઓના સમાન સંગ્રહનો ઉપયોગ કરી રહ્યા છીએ. અમે એક નવું ચલ જનરેટ કરવા માટે _.map નો ઉપયોગ કરી શકીએ છીએ જેમાં તમામ વપરાશકર્તાઓના સંપૂર્ણ નામોની ફ્લેટન્ડ એરે હોય છે.
8. _. તફાવત
તફાવત ફંક્શન મૂલ્યોની નવી એરે પેદા કરશે જે પ્રથમ અને બીજા એરે વચ્ચે અલગ પડે છે. તે નોંધવું મહત્વપૂર્ણ છે કે દલીલોના સ્થાનો પરિણામોને અસર કરે છે.
9. _.મેળવો
_.get() ફંક્શન અમને ઑબ્જેક્ટની અંદર એલિમેન્ટ શોધવામાં મદદ કરી શકે છે. જો પૂરા પાડવામાં આવેલ પાથ પર કોઈ તત્વ ન મળે તો પરત કરવા માટે અમે _.get() ફંક્શન માટે ડિફોલ્ટ મૂલ્ય સેટ કરી શકીએ છીએ. _.get() ફંક્શન ત્રણ પેરામીટર્સ લે છે, જેમાંથી પહેલું તે ઑબ્જેક્ટ છે જેમાંથી આપણે એલિમેન્ટ મેળવવા ઈચ્છીએ છીએ. રસ્તો બીજો છે. ત્રીજું મૂલ્ય એ ડિફૉલ્ટ મૂલ્ય છે જે અમે પરત કરવા માંગીએ છીએ જો કોઈ તત્વ સ્થિત ન થઈ શકે.
10. _.શોધો
_find() ફંક્શન _.get() મેથડ જેવું જ લાગે છે. _.find() ફંક્શન, જેમ કે _.get() પદ્ધતિ, ત્રણ પરિમાણો સ્વીકારે છે. જો કે, _.get() પદ્ધતિથી વિપરીત, પ્રથમ દલીલ એરે અથવા ઑબ્જેક્ટ હોઈ શકે છે. બીજી દલીલ એ ફંક્શનનો ઉલ્લેખ કરે છે જે દરેક પુનરાવર્તન પર કૉલ કરવામાં આવશે. ત્રીજું ઇનપુટ સંગ્રહની શરૂઆતનો સૂચક છે. કારણ કે _.find() ફંક્શન કલેક્શનમાં દરેક એલિમેન્ટ પર પુનરાવર્તિત થાય છે.
11. _.ગ્રુપબાય
ફંક્શનના પરિણામ (અથવા રેન્ડમલી પસંદ કરેલ પ્રોપર્ટી નામ) દ્વારા નામ આપવામાં આવેલ ઑબ્જેક્ટ બનાવો, જેમાં દરેક મૂલ્ય સમાન કી સાથે ઑબ્જેક્ટની શ્રેણી છે.
12. _.સેટ
પદ્ધતિ _.set() એ પદ્ધતિ _.get()ની વ્યસ્ત છે. તે આપેલ પાથ પર તત્વની કિંમત બદલશે. ઑબ્જેક્ટ અથવા એરે એ પ્રથમ પરિમાણ છે, પાથ બીજો છે અને તમે જે મૂલ્ય સેટ કરવા માંગો છો તે ત્રીજું છે.
13. _.મર્જ કરો
તે Object.assign ની જેમ જ કાર્ય કરે છે, સિવાય કે તે ઊંડા ઓબ્જેક્ટ્સને બદલવાને બદલે તેને અપડેટ કરવા માટે અન્ડરલાઇંગ સ્ટ્રક્ચરમાં ફરી ફરી જાય છે.
14. ._deburr
આ એક એકદમ સીધું ઉદાહરણ છે. બધા "સંયોજન ડાયાક્રિટિકલ ચિહ્નો" દૂર કરવામાં આવે છે. આમ “é” “e” બને છે. જ્યારે આંતરરાષ્ટ્રીયકરણ અને સ્થાનિકીકરણ હોય, ત્યારે શોધ કાર્યો માટે ટેક્સ્ટને ડિબરર કરવું એ સારી પ્રથા છે.
15. _.બાઉન્સ
આ લોડાશની સૌથી અસરકારક વ્યૂહરચનાઓમાંની એક છે. તે શું કરે છે અને તમારે ક્યારે તેનો ઉપયોગ કરવો જોઈએ તે સમજવું પણ મુશ્કેલ હોઈ શકે છે. _.debounce() પદ્ધતિ ફંક્શન પરત કરે છે. _.debounce() મેથડનું ફંક્શન છેલ્લી વખત ફંક્શનને બોલાવવામાં આવ્યું ત્યારથી નિર્દિષ્ટ સંખ્યામાં મિલીસેકન્ડ પસાર ન થાય ત્યાં સુધી વિનંતી કરવામાં વિલંબ કરશે.
ઉપસંહાર
લોડાશ એ JavaScript ભાષાનું શક્તિશાળી વિસ્તરણ છે. ન્યૂનતમ પ્રયત્નો સાથે, વ્યક્તિ સંક્ષિપ્ત અને કાર્યક્ષમ કોડ બનાવી શકે છે. લોડાશ પણ સંપૂર્ણપણે મોડ્યુલર છે. જો કે તેની કેટલીક કાર્યક્ષમતા આખરે નાપસંદ થઈ શકે છે, હું માનું છું કે તે હજુ પણ વિકાસકર્તાઓને અસંખ્ય લાભો પ્રદાન કરશે જ્યારે JS ભાષાના ઉત્ક્રાંતિને પણ ચલાવશે.
હું આશા રાખું છું કે લોડાશની આ થોડી ક્ષમતાઓ તમને એરે, ઑબ્જેક્ટ્સ અને સંગ્રહો સાથે કામ કરતી વખતે લોડાશ કેટલી શક્તિશાળી બની શકે છે તે જોવામાં મદદ કરશે. તમે મુલાકાત લઈ શકો છો દસ્તાવેજીકરણ તે ઓફર કરે છે તેવા અન્ય વિકલ્પોની પુષ્કળતાનું અન્વેષણ કરવા માટે.
એક જવાબ છોડો