සංවර්ධකයෙකුට කාර්යයන් සම්පූර්ණ කිරීම පමණක් නොව, කාර්යයන් වඩාත් කාර්යක්ෂමව සිදු කිරීමද අවශ්ය වේ. සංවර්ධකයින් සඳහා විචල්යයන් සමඟ වැඩ කිරීම පහසු කරන පුස්තකාල කිහිපයක් JavaScript හි අද පවතී. අපි මෙම නිබන්ධනය තුළ Lodash පුස්තකාලයේ වඩාත් පොදු කාර්යයන් භාවිතා කරන්නේ කෙසේදැයි ඉගෙන ගනිමු.
ඔබ තවමත් Lodash උත්සාහ කර නොමැති නම්, දැන් මොහොතයි. Lodash යනු සමකාලීන ජාවාස්ක්රිප්ට් උපයෝගිතා පැකේජයක් වන අතර එය අරා, පූර්ණ සංඛ්යා, වස්තු, පෙළ සහ වෙනත් දත්ත වර්ග සමඟ වැඩ කිරීම පහසු කරයි.
එය විවිධ ආකාරයේ වස්තු සමඟ කටයුතු කිරීමට ඔබට සහාය වන අතර සාමාන්ය ක්රම කේත කිරීමේ අවශ්යතාවය ඉවත් කිරීමෙන් ඔබේ කාලය ඉතිරි කරයි. ඔබේ කේතය අඩු රේඛා සමඟ පිරිසිදු වන අතර සියලුම බ්රව්සර්වල ක්රියා කරයි. ඔබ දැනටමත් එය භාවිතා නොකරන්නේ නම්, ඔබ එය ප්රවේශමෙන් සලකා බැලිය යුතුය.
Lodash භාවිතා නොකිරීම අපගේ JavaScript කේත පදනමට විශාල පාඩුවක්. එය අපට වැඩ කිරීමේදී ඇති පොදු අභියෝග සඳහා දෝෂ රහිත සහ අලංකාර විසඳුමක් වන අතර, එය භාවිතා කිරීමෙන් අපගේ කේතය වඩාත් කියවිය හැකි සහ කළමනාකරණය කළ හැකි වේ.
අපි වඩාත් ජනප්රිය (නැතහොත් නැත!) ලෝඩෑෂ් ක්රියාකාරකම් කිහිපයක් සොයා බලමු, මෙම පුස්තකාලය කෙතරම් අතිශයින් ප්රයෝජනවත් සහ අලංකාර දැයි සොයා බලමු.
1. _.sortedUniq
සියලුම අනුපිටපත් අගයන් මෙය සමඟ ආපසු ලබා නොදෙනු ඇත. එය වර්ග කළ අරා සඳහා පමණක් වන නිසා, මෙය ප්රධාන වශයෙන් භාවිත වන්නේ වේග හේතු සඳහා ය. මෙය ප්රයෝජනවත් වන්නේ ඔබ විශාල අරාවක් සමඟ ගනුදෙනු කරන්නේ නම් පමණි. ඔබට වේගය වැඩි දියුණු කිරීමට අවශ්ය නම්, ඔබේ අරාව වර්ග කර වර්ග කළ අරා සමඟ වඩා හොඳින් ක්රියා කරන ක්රම භාවිතා කරන්න.
මේ හා සමාන තවත් කාර්යයන් ගණනාවක් Lodash සතුව ඇත. ඔබට .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy.sortedUniqBy, .sortedUniqBy,
2. _.අඩු කරන්න
_.අඩු කිරීම පෙරහන් ශ්රිතයකට සමාන වේ. එකම වෙනස වන්නේ ඔබට ආපසු ලබා දුන් වස්තුවේ ආකෘතිය තේරීමේ විකල්පයයි. ඒක සාමාන්ය දෙයක්, ඔයාට මම කියන දේ තේරෙන්නේ නැත්නම්; ඒකට උදාහරණයක් තියෙනවා.
සාරාංශයක් ලෙස, අපි වයස අනුව වර්ගීකරණය කරන ලද පරිශීලකයින් අඩංගු නව වස්තුවක් ආපසු ලබා දෙන්නෙමු, නමුත් වයස අවුරුදු 18 සිට 59 දක්වා අය සඳහා පමණි. මෙම Lodash උපකාරක කාර්යය බහුලව භාවිතා වන එකකි. එය ES6 හි ද ඇතුළත් වේ. මට සාමාන්ය වැරදි දෙකක් ද පෙන්වා දීමට අවශ්යයි: ශ්රිතයේ අවසානයේ ප්රතිඵලය ආපසු ලබා දීමට මතක තබා ගන්න, සහ ප්රතිඵලය සඳහා පෙරනිමි අගය තුන්වන පරාමිතිය (මෙහි) ලෙස සැපයීමට මතක තබා ගන්න.
3. _. ලබා ගන්න සහ ._set කරන්න
මේ සඳහා, එකම දේ පාහේ ඉටු කරන කාර්යයන් දෙකක් පෙන්වීමෙන් මම ඔබව තරමක් රවටා ගන්නෙමි. _. වස්තුවකින් දේපල වටිනාකමක් ලබා ගන්න, සහ _.සකසන්න, හොඳයි, ඔබ එය අනුමාන කළා, වටිනාකමක් සහිත දේපලක් සකසන්න. ඔබට දේපලකට එහි මාර්ගය හරහා ප්රවේශ විය හැකි බව හැර, අද්විතීය කිසිවක් නැත.
අපි උදාහරණයක් බලමු.
_.set ඇමතීමේදී මාර්ගය නොපවතියි නම්, එය ජනනය වේ. තවදුරටත් "නිර්වචනය නොකළ දේපල 'අයිතම' සැකසිය නොහැක" දෝෂ ඇති නොවේ. මාර්ගය නොපවතියි නම්, _.get දෝෂයක් වෙනුවට අර්ථ දැක්වීමකින් තොරව ආපසු එනු ඇත. මාර්ගය නිර්වචනය නොකළේ නම්, ඔබට පෙරනිමි අගයක් (තෙවන පරාමිතිය) සැපයිය හැකිය.
4. _.සොයා ගන්න
තනි වස්තුවක් සෙවීමට අරාවක් හරහා ලූප් කිරීම වෙනුවට, අපට _.find භාවිතා කළ හැක. ඒක හොඳයි, නමුත් _.find එකට කරන්න පුළුවන් එකම දේ ඒක නෙවෙයි. තනි කේත පේළියක් සමඟින්, ඔබට බොහෝ ගුණාංග භාවිතා කිරීමෙන් වස්තුවක් සොයා ගත හැක. එය පරික්ෂා කරන්න!
5. _.keyBy
මගේ ප්රියතම එකක් තමයි _.keyBy. යම් ගුණාංගයක් සහිත වස්තුවක් ලබා ගැනීමට උත්සාහ කරන විට එය බෙහෙවින් ප්රයෝජනවත් වේ. අපට බ්ලොග් ඇතුළත් කිරීම් 100 ක් ඇති අතර “34abc” හැඳුනුම්පත ඇති එකක් ලබා ගැනීමට අවශ්ය යැයි උපකල්පනය කරන්න. අපි එය කරන්නේ කෙසේද? බලමු මොකද වෙන්නේ කියලා! සේවාදායකයක් එය අරාවක් ලෙස සපයන්නේ නම්, වස්තු එකතුවක් සැකසීමට මෙම ක්රමය ඔබට උපකාර කරයි. ශ්රිතයක් දෙවන තර්කය ලෙසද භාවිතා කළ හැක.
6. _.එක් එක් සඳහා
මෙම ක්රමය මඟින් ඔබට අවශ්ය ඕනෑම තර්කයක් කිරීමට ඉඩ සලසමින් වස්තු සමූහයක් එකින් එක පුනරාවර්තනය කරයි. මෙම පළමු උදාහරණයේදී, මම පරිශීලක වස්තු ලැයිස්තුවක් ලූප් කරන්නම්, සම්පූර්ණ නම නමින් නව දේපලක් සෑදීමට ඒවායේ මුල් සහ අවසාන නම් ඒකාබද්ධ කරන්න.
මේ එක් එක් පරාමිති දෙකක් පිළිගනී. අපි ලූප් කරන අරාව පළමු පරාමිතියයි. දෙවන තර්කය පුනරාවර්තන ශ්රිතයක් වන අතර, පළමු පරාමිතිය තනි අයිතම යොමුව වන අතර දෙවැන්න පුනරාවර්තනයේ වත්මන් දර්ශකය වේ.
7. _.සිතියම
සිතියම, forEach, අගයන් මාලාවක් හරහා පුනරාවර්තනය වේ. අනෙක් අතට, සිතියම් ශ්රිතය පුනරාවර්තන ශ්රිතය මඟින් සපයන ලද නව අගයන් මාලාවක් ලබා දෙයි. අපි මෙහි අපගේ forEach උදාහරණයේ ඇති එකම පරිශීලක එකතුව භාවිතා කරන්නෙමු. සියලුම පරිශීලකයින්ගේ සම්පූර්ණ නම් වලින් සමතලා කළ අරාවක් ඇති නව විචල්යයක් උත්පාදනය කිරීමට අපි _.map භාවිතා කළ හැක.
8. _.වෙනස
වෙනස ශ්රිතය පළමු සහ දෙවන අරාව අතර වෙනස් වන නව අගයන් මාලාවක් නිපදවනු ඇත. තර්කයේ ස්ථාන ප්රතිඵලවලට බලපාන බව සැලකිල්ලට ගැනීම වැදගත්ය.
9. _.ලබා ගන්න
වස්තුවක් තුළ මූලද්රව්යයක් ස්ථානගත කිරීමට _.get() ශ්රිතය අපට සහාය විය හැක. සැපයූ මාර්ගයෙහි මූලද්රව්යයක් සොයාගත නොහැකි නම්, ආපසු පැමිණීමට _.get() ශ්රිතය සඳහා පෙරනිමි අගයක් අපට සැකසිය හැක. _.get() ශ්රිතය පරාමිති තුනක් ගනී, ඉන් පළමුවැන්න නම් අපි මූලද්රව්යයක් ලබා ගැනීමට බලාපොරොත්තු වන වස්තුවයි. මාර්ගය දෙවැන්නයි. තුන්වන අගය යනු මූලද්රව්යයක් ස්ථානගත කළ නොහැකි නම් අපට ආපසු ලබා දීමට අවශ්ය පෙරනිමි අගයයි.
10. _.සොයා ගන්න
_find() ශ්රිතය _.get() ක්රමයට සමාන විය හැක. _.get() ක්රමය වැනි _.find() ශ්රිතය පරාමිති තුනක් පිළිගනී. කෙසේ වෙතත්, _.get() ක්රමය මෙන් නොව, පළමු තර්කය අරාවක් හෝ වස්තුවක් විය හැක. දෙවන තර්කය එක් එක් පුනරාවර්තනය සඳහා කැඳවනු ලබන ශ්රිතය නියම කරයි. තෙවන ආදානය එකතුවේ ආරම්භක දර්ශකයයි. _.find() ශ්රිතය එකතුවක එක් එක් මූලද්රව්ය මත පුනරාවර්තනය වන බැවිනි.
11. _.groupBy
ශ්රිතයක ප්රතිඵලයක් (හෝ අහඹු ලෙස තෝරාගත් දේපල නාමයක්) මගින් නම් කරන ලද වස්තුවක් සාදන්න, සෑම අගයක්ම එකම යතුරක් සහිත වස්තු මාලාවක් වේ.
12. _. කට්ටලය
_.set() ක්රමය _.get() ක්රමයේ ප්රතිලෝම වේ. එය දී ඇති මාර්ගයක ඇති මූලද්රව්යයක අගය වෙනස් කරයි. වස්තුව හෝ අරාව යනු පළමු පරාමිතිය වන අතර, මාර්ගය දෙවැන්න වන අතර, ඔබට සැකසීමට අවශ්ය අගය තුන්වන පරාමිතිය වේ.
13. _.ඒකාබද්ධ කරන්න
එය Object.assign හා සමානව ක්රියා කරයි, එය ප්රතිස්ථාපනය කිරීමට වඩා ගැඹුරු වස්තු යාවත්කාලීන කිරීම සඳහා යටින් පවතින ව්යුහය තුළට ගැඹුරට ප්රතිවර්තනය වීම හැර.
14. ._deburr
මෙය තරමක් සරල උදාහරණයකි. සියලුම "ඒකාබද්ධ diacritical සලකුණු" ඉවත් කරනු ලැබේ. මේ අනුව "é" "e" බවට පත් වේ. ජාත්යන්තරකරණය සහ ප්රාදේශීයකරණය ඇති විට, සෙවුම් කාර්යයන් සඳහා පෙළ ඉවත් කිරීම හොඳ පුරුද්දකි.
15. _.debounce
මෙය වඩාත් ඵලදායී Lodash උපාය මාර්ගයකි. එය කරන්නේ කුමක්ද සහ ඔබ එය භාවිතා කළ යුත්තේ කවදාද යන්න තේරුම් ගැනීමටද අපහසු විය හැකිය. _.debounce() ක්රමය ශ්රිතයක් ලබා දෙයි. _.debounce() ක්රමයේ ශ්රිතය ශ්රිතය අවසන් වරට ක්රියාත්මක කළ දින සිට නිශ්චිත මිලි තත්පර ගණනක් ගත වන තෙක් ආයාචනය ප්රමාද කරයි.
නිගමනය
Lodash යනු JavaScript භාෂාවේ ප්රබල දිගුවකි. අවම උත්සාහයකින්, කෙනෙකුට සංක්ෂිප්ත සහ කාර්යක්ෂම කේතයක් ගොඩනගා ගත හැකිය. Lodash ද සම්පූර්ණයෙන්ම මොඩියුලර් වේ. එහි සමහර ක්රියාකාරීත්වය අවසානයේ අත්හරිනු ලැබිය හැකි වුවද, JS භාෂාවේ පරිණාමය ද ගෙන යන අතරම එය සංවර්ධකයින්ට බොහෝ ප්රතිලාභ ලබා දෙනු ඇතැයි මම විශ්වාස කරමි.
අරා, වස්තු සහ එකතු කිරීම් සමඟ වැඩ කිරීමේදී Lodash කෙතරම් බලවත් දැයි බැලීමට මෙම Lodash හැකියාවන් කිහිපය ඔබට උපකාර වනු ඇතැයි මම බලාපොරොත්තු වෙමි. ඔබට සංචාරය කළ හැකිය ලේඛගතකිරීම එය ඉදිරිපත් කිරීමට ඇති වෙනත් විකල්ප රාශියක් ගවේෂණය කිරීමට.
ඔබමයි