វាមិនត្រឹមតែតម្រូវឱ្យអ្នកអភិវឌ្ឍន៍បំពេញកិច្ចការប៉ុណ្ណោះទេ ប៉ុន្តែវាក៏ចាំបាច់ផងដែរក្នុងការបំពេញការងារឱ្យមានប្រសិទ្ធភាពជាងមុន។ មានបណ្ណាល័យជាច្រើនដែលមាននៅក្នុង JavaScript សព្វថ្ងៃនេះ ដែលធ្វើអោយការធ្វើការជាមួយអថេរកាន់តែងាយស្រួលសម្រាប់អ្នកអភិវឌ្ឍន៍។ យើងនឹងរៀនពីរបៀបប្រើប្រាស់មុខងារធម្មតាបំផុតរបស់បណ្ណាល័យ Lodash នៅក្នុងការបង្រៀននេះ។
ប្រសិនបើអ្នកមិនទាន់បានសាកល្បង Lodash នៅឡើយទេ ឥឡូវនេះគឺជាពេលវេលា។ Lodash គឺជាកញ្ចប់ឧបករណ៍ប្រើប្រាស់ JavaScript សហសម័យដែលសម្រួលការធ្វើការជាមួយអារេ ចំនួនគត់ វត្ថុ អត្ថបទ និងប្រភេទទិន្នន័យផ្សេងទៀតកាន់តែងាយស្រួល។
វានឹងជួយអ្នកក្នុងការដោះស្រាយជាមួយប្រភេទផ្សេងៗនៃវត្ថុ ហើយនឹងជួយសន្សំសំចៃពេលវេលារបស់អ្នកដោយលុបបំបាត់តម្រូវការក្នុងការសរសេរកូដវិធីសាស្រ្តទូទៅ។ លេខកូដរបស់អ្នកនឹងកាន់តែស្អាតជាមួយនឹងបន្ទាត់តិចជាង ហើយនឹងដំណើរការនៅក្នុងកម្មវិធីរុករកទាំងអស់។ ប្រសិនបើអ្នកមិនទាន់ប្រើវាទេ អ្នកគួរតែពិចារណាវាឱ្យបានល្អិតល្អន់។
ការមិនទទួលយក Lodash គឺជាការខាតបង់ដ៏ធំសម្រាប់មូលដ្ឋានកូដ JavaScript របស់យើង។ វាគឺជាដំណោះស្រាយដែលមិនមានកំហុស និងឆើតឆាយចំពោះបញ្ហាប្រឈមទូទៅដែលយើងមាននៅកន្លែងធ្វើការ ហើយការប្រើប្រាស់វានឹងធ្វើឱ្យកូដរបស់យើងកាន់តែអាចអានបាន និងអាចគ្រប់គ្រងបាន។
ចូរស្វែងយល់ពីមុខងារ Lodash ដែលពេញនិយម (ឬអត់!) មួយចំនួន ហើយស្វែងយល់ថាតើបណ្ណាល័យនេះមានប្រយោជន៍ និងស្រស់ស្អាតប៉ុណ្ណា។
1. _.sortedUniq
តម្លៃស្ទួនទាំងអស់នឹងមិនត្រូវបានបញ្ជូនមកវិញជាមួយនឹងតម្លៃនេះទេ។ ដោយសារតែវាគ្រាន់តែសម្រាប់ការតម្រៀបអារេ នេះត្រូវបានប្រើជាចម្បងសម្រាប់ហេតុផលល្បឿន។ វាមានប្រយោជន៍តែប្រសិនបើអ្នកកំពុងដោះស្រាយជាមួយអារេធំ។ ប្រសិនបើអ្នកចង់បង្កើនល្បឿន សូមតម្រៀបអារេរបស់អ្នក ហើយប្រើវិធីដែលដំណើរការល្អជាងជាមួយអារេដែលបានតម្រៀប។
Lodash មានមុខងារមួយចំនួនផ្សេងទៀតដែលស្រដៀងនឹងនេះ។ អ្នកអាចមើល .sortedIndex, .sortedIndexBy, .sortedIndexOf, .sortedLastIndex, .sortedLastIndexBy, .sortedLastIndexOf, .sortedUniq, .sortedUniqBy, .sortedUniqBy, .By sorted
2. _.កាត់បន្ថយ
_.reduce គឺស្រដៀងទៅនឹងមុខងារតម្រង។ ភាពខុសគ្នាតែមួយគត់គឺថាអ្នកមានជម្រើសក្នុងការជ្រើសរើសទម្រង់នៃវត្ថុដែលបានត្រឡប់មកវិញ។ វាជារឿងធម្មតាទេ ប្រសិនបើអ្នកមិនយល់ពីអ្វីដែលខ្ញុំកំពុងនិយាយ។ មានឧទាហរណ៍សម្រាប់វា។
ជារួម យើងប្រគល់វត្ថុថ្មីដែលមានអ្នកប្រើប្រាស់ចាត់ថ្នាក់តាមអាយុ ប៉ុន្តែសម្រាប់តែអ្នកដែលមានអាយុពី 18 ដល់ 59 ឆ្នាំ។ មុខងារជំនួយ Lodash នេះគឺជាផ្នែកមួយនៃការប្រើប្រាស់ច្រើនបំផុត។ វាត្រូវបានរួមបញ្ចូលផងដែរនៅក្នុង ES6 ។ ខ្ញុំក៏ចង់ចង្អុលបង្ហាញពីកំហុសឆ្គងធម្មតាចំនួនពីរផងដែរ៖ ចងចាំថាត្រូវបញ្ជូនលទ្ធផលមកវិញនៅពេលបញ្ចប់មុខងារ ហើយផ្តល់តម្លៃលំនាំដើមសម្រាប់លទ្ធផលជាប៉ារ៉ាម៉ែត្រទីបី (នៅទីនេះ)។
3. _.get និង ._set
សម្រាប់មួយនេះ ខ្ញុំនឹងបញ្ឆោតអ្នកបន្តិចដោយបង្ហាញមុខងារពីរដែលដំណើរការស្ទើរតែដូចគ្នា។ _.get ត្រឡប់តម្លៃទ្រព្យសម្បត្តិពីវត្ថុមួយ ហើយ _.set ជាការប្រសើរណាស់ អ្នកបានទាយវា កំណត់ទ្រព្យសម្បត្តិដោយតម្លៃមួយ។ គ្មានអ្វីប្លែកទេ លើកលែងតែអ្នកអាចចូលប្រើប្រាស់អចលនទ្រព្យតាមរយៈផ្លូវរបស់វា។
ចូរយើងមើលឧទាហរណ៍មួយ។
ប្រសិនបើផ្លូវមិនមាននៅពេលហៅ _.set វានឹងត្រូវបានបង្កើត។ វានឹងលែងមានកំហុស "មិនអាចកំណត់លក្ខណៈ 'ធាតុ' នៃការមិនបានកំណត់" ទៀតទេ។ ប្រសិនបើផ្លូវមិនមានទេ _.get នឹងត្រឡប់មិនបានកំណត់ជំនួសឱ្យកំហុស។ ប្រសិនបើផ្លូវដោះស្រាយទៅមិនបានកំណត់ អ្នកក៏អាចផ្តល់តម្លៃលំនាំដើម (ប៉ារ៉ាម៉ែត្រទីបី) ផងដែរ។
4. _.រក
ជំនួសឱ្យការរង្វិលជុំតាមអារេដើម្បីស្វែងរកវត្ថុតែមួយ យើងអាចប្រើ _.find ។ នោះជាការល្អ ប៉ុន្តែវាមិនមែនជារឿងតែមួយគត់ដែល _.find អាចធ្វើបាននោះទេ។ ជាមួយនឹងបន្ទាត់តែមួយនៃកូដ អ្នកក៏អាចរកឃើញវត្ថុមួយដោយប្រើប្រាស់លក្ខណៈសម្បត្តិជាច្រើនផងដែរ។ ពិនិត្យមើលវាចេញ!
5. _.keyBy
មួយក្នុងចំនោមចំណូលចិត្តរបស់ខ្ញុំគឺ _.keyBy ។ វាមានប្រយោជន៍ណាស់នៅពេលព្យាយាមទទួលបានវត្ថុដែលមានគុណលក្ខណៈជាក់លាក់មួយ។ សន្មតថាយើងមាន 100 ធាតុប្លុក ហើយចង់ចាប់យកមួយដែលមានលេខសម្គាល់ "34abc" ។ តើយើងនឹងធ្វើវាដោយរបៀបណា? ចាំមើលថាមានអ្វីកើតឡើង! វិធីសាស្រ្តនេះអាចជួយអ្នករៀបចំការប្រមូលវត្ថុប្រសិនបើម៉ាស៊ីនមេផ្តល់វាជាអារេ។ អនុគមន៍មួយក៏អាចត្រូវបានប្រើជាអាគុយម៉ង់ទីពីរផងដែរ។
6. _.សម្រាប់គ្នា
វិធីសាស្រ្តនេះនឹងធ្វើឡើងវិញលើអារេនៃវត្ថុម្តងមួយៗ ដែលអនុញ្ញាតឱ្យអ្នកធ្វើអ្វីដែលអ្នកចង់បាន។ ក្នុងឧទាហរណ៍ដំបូងនេះ ខ្ញុំនឹងលើកបញ្ជីវត្ថុអ្នកប្រើប្រាស់ ដោយបញ្ចូលឈ្មោះ និងនាមត្រកូលរបស់ពួកគេ ដើម្បីបង្កើតទ្រព្យសម្បត្តិថ្មីហៅថា fullName ។
សម្រាប់ការទាំងនេះនីមួយៗទទួលយកប៉ារ៉ាម៉ែត្រពីរ។ អារេដែលយើងកំពុងរង្វិលជុំគឺជាប៉ារ៉ាម៉ែត្រទីមួយ។ អាគុយម៉ង់ទីពីរគឺជាអនុគមន៍ដែលធ្វើម្តងទៀត ដោយប៉ារ៉ាម៉ែត្រទីមួយគឺជាសេចក្តីយោងធាតុបុគ្គល ហើយទីពីរគឺជាសន្ទស្សន៍បច្ចុប្បន្នរបស់ការធ្វើម្តងទៀត។
7. _.map
ផែនទី ដូចជា forEach ធ្វើម្តងទៀតនៅទូទាំងអារេនៃតម្លៃ។ ម្យ៉ាងវិញទៀត មុខងារផែនទី ត្រឡប់តម្លៃអារេថ្មីដែលផ្តល់ដោយអនុគមន៍ដដែលៗ។ យើងកំពុងប្រើប្រាស់ការប្រមូលអ្នកប្រើប្រាស់ដូចគ្នាដូចនៅក្នុងឧទាហរណ៍របស់យើងនៅទីនេះ។ យើងអាចប្រើ _.map ដើម្បីបង្កើតអថេរថ្មីមួយដែលមានអារេបង្រួបបង្រួមនៃឈ្មោះពេញលេញរបស់អ្នកប្រើប្រាស់ទាំងអស់។
8. _.ភាពខុសគ្នា
មុខងារភាពខុសគ្នានឹងបង្កើតតម្លៃថ្មីនៃតម្លៃដែលខុសគ្នារវាងអារេទីមួយ និងទីពីរ។ វាសំខាន់ណាស់ក្នុងការកត់សម្គាល់ថាទីតាំងនៃអាគុយម៉ង់ប៉ះពាល់ដល់លទ្ធផល។
9. _.ទទួលបាន
មុខងារ _.get() អាចជួយយើងក្នុងការកំណត់ទីតាំងធាតុនៅក្នុងវត្ថុមួយ។ យើងអាចកំណត់តម្លៃលំនាំដើមសម្រាប់អនុគមន៍ _.get() ដើម្បីត្រឡប់ ប្រសិនបើរកមិនឃើញធាតុនៅផ្លូវដែលបានផ្គត់ផ្គង់។ អនុគមន៍ _.get() យកប៉ារ៉ាម៉ែត្របី ដែលទីមួយគឺជាវត្ថុដែលយើងចង់ទទួលបានធាតុមួយ។ ផ្លូវគឺទីពីរ។ តម្លៃទីបីគឺជាតម្លៃលំនាំដើមដែលយើងចង់ត្រឡប់ប្រសិនបើធាតុមិនអាចមានទីតាំង។
10. _.រក
អនុគមន៍ _find() អាចទំនងដូចគ្នានឹងវិធីសាស្ត្រ _.get()។ មុខងារ _.find() ដូចជាវិធីសាស្ត្រ _.get() ទទួលយកប៉ារ៉ាម៉ែត្របី។ ទោះយ៉ាងណាក៏ដោយ មិនដូចវិធីសាស្ត្រ _.get() ទេ អាគុយម៉ង់ទីមួយអាចជាអារេ ឬវត្ថុមួយ។ អាគុយម៉ង់ទីពីរបញ្ជាក់មុខងារដែលនឹងត្រូវបានហៅនៅលើការធ្វើម្តងទៀតនីមួយៗ។ ការបញ្ចូលទីបីគឺជាសន្ទស្សន៍ចាប់ផ្តើមនៃការប្រមូល។ ដោយសារតែមុខងារ _.find() ធ្វើម្តងទៀតលើធាតុនីមួយៗក្នុងបណ្តុំមួយ។
11. _.groupBy
បង្កើតវត្ថុមួយដែលមានឈ្មោះដោយលទ្ធផលនៃអនុគមន៍ (ឬឈ្មោះលក្ខណសម្បត្តិដែលបានជ្រើសរើសដោយចៃដន្យ) ដោយតម្លៃនីមួយៗជាអារេនៃវត្ថុដែលមានសោដូចគ្នា។
12. _.set
វិធីសាស្ត្រ _.set() គឺជាការបញ្ច្រាសនៃ method _.get()។ វានឹងផ្លាស់ប្តូរតម្លៃនៃធាតុនៅផ្លូវដែលបានផ្តល់ឱ្យ។ វត្ថុ ឬអារេគឺជាប៉ារ៉ាម៉ែត្រទីមួយ ផ្លូវគឺទីពីរ ហើយតម្លៃដែលអ្នកចង់កំណត់គឺទីបី។
13. _.បញ្ចូលគ្នា
វាដំណើរការស្រដៀងគ្នាទៅនឹង Object.assign លើកលែងតែវាដំណើរការឡើងវិញយ៉ាងជ្រៅទៅក្នុងរចនាសម្ព័ន្ធមូលដ្ឋានដើម្បីធ្វើបច្ចុប្បន្នភាពវត្ថុដែលជ្រៅជាងការជំនួសពួកគេ។
14. ._deburr
នេះជាឧទាហរណ៍ជាក់ស្តែង។ រាល់ "ការរួមបញ្ចូលសញ្ញាសម្គាល់តាមវេយ្យាករណ៍" ទាំងអស់ត្រូវបានដកចេញ។ ដូច្នេះ "អ៊ី" ក្លាយជា "អ៊ី" ។ នៅពេលដែលមានអន្តរភាវូបនីយកម្ម និងការធ្វើមូលដ្ឋានីយកម្ម វាគឺជាការអនុវត្តដ៏ល្អក្នុងការបំបាត់ចោលអត្ថបទសម្រាប់មុខងារស្វែងរក។
15. _.debounce
នេះគឺជាយុទ្ធសាស្ត្រ Lodash ដែលមានប្រសិទ្ធភាពបំផុត។ វាក៏ប្រហែលជាពិបាកក្នុងការយល់ពីអ្វីដែលវាធ្វើ និងពេលណាដែលអ្នកគួរប្រើវា។ វិធីសាស្ត្រ _.debounce() ត្រឡប់មុខងារមួយ។ មុខងាររបស់វិធីសាស្ត្រ _.debounce() នឹងពន្យាការហៅរហូតដល់ចំនួនមីលីវិនាទីដែលបានបញ្ជាក់បានកន្លងផុតទៅ ចាប់តាំងពីមុខងារត្រូវបានហៅចុងក្រោយ។
សន្និដ្ឋាន
Lodash គឺជាផ្នែកបន្ថែមដ៏មានឥទ្ធិពលនៃភាសា JavaScript ។ ជាមួយនឹងការខិតខំប្រឹងប្រែងតិចតួច មនុស្សម្នាក់អាចបង្កើតកូដយ៉ាងខ្លី និងមានប្រសិទ្ធភាព។ Lodash ក៏ជាម៉ូឌុលទាំងស្រុងផងដែរ។ ទោះបីជាមុខងារមួយចំនួនរបស់វានៅទីបំផុតអាចត្រូវបានបដិសេធក៏ដោយ ខ្ញុំជឿថាវានឹងនៅតែផ្តល់អត្ថប្រយោជន៍ជាច្រើនដល់អ្នកអភិវឌ្ឍន៍ ខណៈពេលដែលជំរុញឱ្យមានការវិវត្តនៃភាសា JS ផងដែរ។
ខ្ញុំសង្ឃឹមថាសមត្ថភាព Lodash មួយចំនួននេះអាចជួយអ្នកឱ្យឃើញថាតើ Lodash មានឥទ្ធិពលយ៉ាងណានៅពេលធ្វើការជាមួយអារេ វត្ថុ និងបណ្តុំ។ អ្នកអាចទៅទស្សនា ឯកសារ ដើម្បីស្វែងរកជម្រើសជាច្រើនផ្សេងទៀត ដែលវាមានផ្តល់ជូន។
សូមផ្ដល់យោបល់