មាតិកា[លាក់][បង្ហាញ]
- 1. កែលម្អចំណេះដឹងមូលដ្ឋានរបស់អ្នក។
- 2. ប្រើយុទ្ធសាស្រ្តតម្រង់ទិសវត្ថុ
- 3. ប្រើមុខងារទោះបីជាវាតូចក៏ដោយ។
- 4. ជំនួសឱ្យ == ប្រើ ===
- 5. ប្រើ JSLint
- 6. ស្គ្រីបគួរតែត្រូវបានដាក់នៅខាងក្រោមទំព័ររបស់អ្នក។
- 7. វិធីលឿនបំផុតដើម្បីធ្វើខ្សែអក្សរ
- 8. បន្ថែមមតិយោបល់ទៅលេខកូដរបស់អ្នក។
- 9. ប្រើអក្សរពុម្ពគំរូ
- 10. Iterators និងសម្រាប់ ... នៃ Loops
- 11. ប្រើ {} ជំនួសឱ្យវត្ថុថ្មី ()
- 12. ពិចារណាដាក់ let and const នៅក្នុងលេខកូដរបស់អ្នក។
- 13. eval() មិនមែនជាគំនិតល្អទេ។
- 14. Spread Operator មកយ៉ាងងាយស្រួល
- 15. រង់ចាំនិងធ្វើសមកាលកម្ម
- 16. ប្រើវិធីសាស្រ្ត include() ក្នុង Javascript
- 17. យកធាតុចេញពីអារេដោយប្រើ Splice
- 18. ប្រើមុខងារព្រួញ
- 19. ជាមួយនឹង Destructuring អ្នកអាចកំណត់តម្លៃអថេរបានយ៉ាងឆាប់រហ័ស
- 20. បង្កើតគម្រោងជាច្រើន។
- សន្និដ្ឋាន
ប្រសិនបើអ្នកធ្លាប់ចាប់អារម្មណ៍លើការអភិវឌ្ឍន៍គេហទំព័រ អ្នកប្រហែលជាបានឆ្លងកាត់ JavaScript។ ភាសាសរសេរកម្មវិធីតម្រង់ទិសវត្ថុគឺ JavaScript ។ អ្នកអភិវឌ្ឍន៍ប្រើវាដើម្បីធ្វើឱ្យគេហទំព័ររបស់ទំព័រអតិថិជន (ផ្នែកខាងមុខ) ថាមវន្ត និងអន្តរកម្ម។
វាក៏ត្រូវបានប្រើដើម្បីបង្កើតគេហទំព័រ និងកម្មវិធីបណ្ដាញជាមួយ HTML និង CSS ។ សព្វថ្ងៃនេះមិនមានគេហទំព័រនៅលើអ៊ីនធឺណិតដែលមិនមានកូដ JavaScript ទេ។ វាក្លាយជាទិដ្ឋភាពដែលមិនអាចកាត់ថ្លៃបាននៃការងាររបស់អ្នកអភិវឌ្ឍន៍។
ជាការពិតវាកំពុងកើនឡើងជាលំដាប់។ ទោះបីជា JavaScript ត្រូវបានគេទទួលស្គាល់ថាល្អបំផុតសម្រាប់ការផ្តល់មុខងារដល់គេហទំព័រក៏ដោយ វាក៏ត្រូវបានប្រើប្រាស់នៅក្នុងបរិស្ថានដែលមិនមែនជា JavaScript ផងដែរ។ Node.js, Apache Couch-DB, និង Adobe Acrobat គឺជាឧទាហរណ៍នៃបច្ចេកវិទ្យាទាំងនេះ។ សម្រាប់ដំណើរការ JavaScript កម្មវិធីរុករកតាមអ៊ីនធឺណិតទំនើបភាគច្រើនមានម៉ាស៊ីនប្រតិបត្តិ JavaScript ដែលភ្ជាប់មកជាមួយ។ ប្រសិនបើអ្នកចង់ក្លាយជាអ្នកអភិវឌ្ឍន៍គេហទំព័រជោគជ័យ អ្នកនឹងត្រូវដោះស្រាយជាមួយ JavaScript ។
អ្នកត្រូវតែដោះស្រាយវានៅថ្ងៃនេះឬថ្ងៃស្អែក។ ហេតុអ្វីមិនរៀន JavaScript ឱ្យបានមុនម៉ោង ដូច្នេះអ្នកនឹងត្រៀមខ្លួននៅពេលដែលពេលវេលាមកដល់?
នេះជាអ្វីដែលអ្នកនឹងរៀននៅក្នុងវគ្គនេះ។ វាពន្យល់ពីរបៀបរក្សាបានមួយជំហានមុនអ្នកបង្កើតគេហទំព័ររបស់អ្នកដោយធ្វើឱ្យ JavaScript របស់អ្នកប្រសើរឡើង។
តោះចាប់ផ្ដើម!
1. កែលម្អចំណេះដឹងមូលដ្ឋានរបស់អ្នក។
ខ្ញុំនឹងចាប់ផ្ដើមដោយការគិតនិងសេចក្តីថ្លែងការណ៍ជាមូលដ្ឋានដែលអ្នកបានឮតាំងពីអ្នកនៅក្មេង។ រៀនមូលដ្ឋានគ្រឹះ ហើយយកទៅអនុវត្ត។ ជាច្រើនដង អ្នកនឹងអនុវត្តតក្កវិជ្ជាជាមួយការសរសេរកូដ ប៉ុន្តែអ្នកនឹងភ្លេចថាមានមុខងារដែលភ្ជាប់មកជាមួយរួចហើយសម្រាប់វា ដូចជាការកាត់អារេជាដើម។ នៅពេលអ្នកដំណើរការកូដ JavaScript អ្នកអាចទទួលបានកំហុស ហើយជាលទ្ធផល មុខងារបន្ថែមជាច្រើនឈប់ដំណើរការ។
នេះអាចបណ្តាលមកពីពោះវៀនធំតែមួយ ឬសញ្ញាក្បៀសដាក់បញ្ច្រាស។ រឿងទាំងនេះកើតឡើងដោយសារការខ្វះការយល់ដឹងអំពីមូលដ្ឋានគ្រឹះ។ ជាច្រើនដងនៅក្នុងកម្មវិធីតែមួយ រង្វិលជុំមូលដ្ឋានដូចជាសម្រាប់ ដែល ឬធ្វើខណៈពេលដែលត្រូវបានប្រើប្រាស់។ Loops គឺជាផ្នែកមួយនៃការបង្កើតកម្មវិធីជាមូលដ្ឋានបំផុត។
វាពិតជាលំបាកណាស់ក្នុងការសរសេរកូដ ហើយថែមទាំងមានឱកាសធ្វើការឱ្យក្រុមហ៊ុនមួយ ប្រសិនបើអ្នកមិនស៊ាំនឹងរង្វិលជុំ និងមូលដ្ឋានគ្រឹះផ្សេងទៀត។ ការស្វែងយល់ពីមូលដ្ឋានគ្រឹះរបស់អ្នកគឺសំខាន់ណាស់ ព្រោះវាផ្តល់នូវមូលដ្ឋានគ្រឹះដ៏រឹងមាំមួយ ដើម្បីបង្កើតតក្កវិជ្ជា និងកេរ្តិ៍ឈ្មោះដ៏ស្មុគស្មាញរបស់ដំណោះស្រាយ។
2. ប្រើយុទ្ធសាស្រ្តតម្រង់ទិសវត្ថុ
វិធីសាស្រ្តតម្រង់ទិសវត្ថុគឺជាវិធីសាស្រ្តសរសេរកម្មវិធីល្បីបំផុតនាពេលបច្ចុប្បន្ននេះ។ វិធីសាស្រ្តតម្រង់ទិសវត្ថុដែលបានចាប់ផ្តើមជាមួយ C ++ បានកើនឡើងនៅក្នុងប្រជាប្រិយភាពយ៉ាងខ្លាំងចាប់តាំងពីពេលនោះមក។ សព្វថ្ងៃនេះ មានតែការសរសេរកម្មវិធីតម្រង់ទិសវត្ថុប៉ុណ្ណោះដែលត្រូវបានប្រើដើម្បីបង្កើតភាសាសំខាន់ៗទាំងអស់។ យុទ្ធសាស្ត្រតម្រង់ទិសវត្ថុ គឺជាយុទ្ធសាស្ត្រមួយដែលផ្តោតលើវត្ថុជាក់លាក់មួយ។
បន្ទាប់មកធាតុក្លាយជាអង្គភាពមូលដ្ឋាន។ បន្ទាប់មកវត្ថុនេះត្រូវបានប្រើដើម្បីបន្ថែមគុណលក្ខណៈ និងមុខងារទៅទំព័រជាមូលដ្ឋាន។ អ្នកក៏អាចប្រើវិធីសាស្រ្តប្រពៃណីនៃការបង្កើតកូដពីកំពូលទៅបាតដោយគ្មានមុខងារ ឬវត្ថុណាមួយឡើយ។ នេះគឺទូលំទូលាយពេក ហើយមិនគួរព្យាយាមទេ។ នៅពេលបង្កើតកូដ យើងគួរប្រើវិធីសាស្រ្តមុខងារ ហើយប្រសិនបើយើងប្រើប្រាស់មុខងារ យើងគួរតែប្រើវត្ថុ។
ដូច្នេះនៅពេលចាប់ផ្តើម សូមព្យាយាមបំប្លែងកូដទូលំទូលាយរបស់អ្នកទៅជាកូដតម្រង់ទិសវត្ថុ ហើយតែងតែសរសេរកូដរបស់អ្នកក្នុងរចនាប័ទ្មទិសវត្ថុ។ នៅពេលអ្នកសិក្សាកូដរបស់អ្នកដទៃ អ្នកនឹងសម្លឹងមើលបច្ចេកទេសតម្រង់ទិសវត្ថុជានិច្ច។ ប្រសិនបើអ្នកចង់ធ្វើជាម្ចាស់ JavaScript វាជាការល្អបំផុតប្រសិនបើអ្នកយកដៃរបស់អ្នកនៅលើវា។
3. ប្រើមុខងារទោះបីជាវាតូចក៏ដោយ។
ការសរសេរកម្មវិធីជាមួយនឹងវិធីសាស្រ្តមុខងារគឺជាវិធីដ៏អស្ចារ្យមួយដែលត្រូវទៅ។ ហេតុអ្វី? វាបំបែកកម្មវិធីរបស់អ្នកទៅជាម៉ូឌុលដែលដំណើរការជាមួយគ្នា ប៉ុន្តែនៅតែខុសគ្នាពីគ្នាទៅវិញទៅមក។ ខ្ញុំសូមលើកឧទាហរណ៍មួយ ដើម្បីជួយអ្នកយល់។
Root Mean Square នៃចំនួនគត់អាចត្រូវបានគណនាដោយប្រើមុខងារមួយ។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវដាក់ចំនួនគត់ការ៉េ គណនាមធ្យមរបស់វា ហើយបន្ទាប់មកគណនាឫសការ៉េនៃមធ្យម។ មានបីដំណាក់កាលនៅក្នុងដំណើរការ។ ជាលទ្ធផលយើងអាចប្រើមុខងារបី។ ប៉ុន្តែដូចដែលអ្នកបានឃើញ មុខងារទាំងអស់នេះគឺមានទំនាក់ទំនងគ្នាទៅវិញទៅមក។ លទ្ធផលនៃមួយត្រូវបានបញ្ជូនទៅមួយទៀត ហើយយើងទទួលបានលទ្ធផលចុងក្រោយ។
ចូរធ្វើពុតថាជំនួសឱ្យមុខងារបី អ្នកគ្រាន់តែត្រូវការមួយដើម្បីគណនា RMS ដោយផ្អែកលើកត្តាជាច្រើន។ ដំណោះស្រាយចុងក្រោយ ដូចដែលអ្នកអាចឃើញគឺមិនត្រឹមត្រូវទេ។ វានឹងពិបាកណាស់សម្រាប់អ្នកក្នុងការកំណត់នូវអ្វីដែលខុសនៅក្នុងព្រឹត្តិការណ៍ដ៏ធំមួយនៅចំណុចនេះ។
ម្យ៉ាងវិញទៀត ការមានមុខងារតូចៗចំនួនបីនឹងអនុញ្ញាតឱ្យអ្នកវិភាគបានយ៉ាងឆាប់រហ័ស។ ជាលទ្ធផល ទោះបីជាមុខងារមានកម្រិតតិចតួចក៏ដោយ ប្រើប្រាស់ពួកវាដើម្បីកំណត់ម៉ូឌុលកូដផ្សេងគ្នា។ បច្ចេកទេសនេះនឹងជួយអ្នកឱ្យក្លាយជាអ្នកជំនាញ JavaScript ដូចជាវេទមន្ត។
ឥឡូវនេះ សូមក្រឡេកមើលគន្លឹះសរសេរកូដ JavaScript មួយចំនួន។
4. ជំនួសឱ្យ == ប្រើ ===
នៅក្នុង JavaScript ប្រតិបត្តិករសមភាពមានពីរប្រភេទ៖ ប្រតិបត្តិករសមភាពតឹងរឹង === និង !== និងប្រតិបត្តិករសមភាពមិនតឹងរឹង == និង != ។ នៅពេលប្រៀបធៀប វាត្រូវបានចាត់ទុកថាជាការអនុវត្តល្អបំផុត ដើម្បីតែងតែប្រើសមភាពពិតប្រាកដ។ នៅពេលធ្វើការជាមួយ == និង != អ្នកនឹងជួបបញ្ហានៅពេលដោះស្រាយជាមួយប្រភេទផ្សេងៗគ្នា។
នៅពេលដែលប្រភេទនៃតម្លៃដែលអ្នកកំពុងប្រៀបធៀបគឺខុសគ្នា ប្រតិបត្តិករដែលមិនតឹងរ៉ឹងនឹងព្យាយាមបង្ខិតបង្ខំតម្លៃរបស់ពួកគេ ដែលអាចនាំទៅរកលទ្ធផលដែលមិនរំពឹងទុក។
5. ប្រើ JSLint
Douglas Crockford បានបង្កើត JSLint ដែលជាអ្នកបំបាត់កំហុស។ គ្រាន់តែដាក់ស្គ្រីបរបស់អ្នកចូលទៅក្នុងប្រអប់ ហើយវានឹងស្កែនវាយ៉ាងលឿនដើម្បីរកឃើញកំហុសឬគុណវិបត្តិ។
JSLint ពិនិត្យឯកសារប្រភព JavaScript ។ ប្រសិនបើបញ្ហាត្រូវបានរកឃើញ វាផ្ញើសារជាមួយនឹងការពិពណ៌នាអំពីបញ្ហា និងទីតាំងប្រហាក់ប្រហែលនៅក្នុងប្រភព។ បញ្ហានេះមិនតែងតែជាកំហុសវាក្យសម្ព័ន្ធទេ ទោះបីជាវាជាករណីញឹកញាប់ក៏ដោយ។
JSLint ពិនិត្យទាំងបទដ្ឋានរចនាប័ទ្ម និងបញ្ហារចនាសម្ព័ន្ធ។ វាមិនមានន័យថាកម្មវិធីរបស់អ្នកត្រឹមត្រូវនោះទេ។ វាគ្រាន់តែបន្ថែមភ្នែកមួយគូទៀត ដើម្បីជួយក្នុងការរកឃើញបញ្ហា។ មុនពេលអ្នកចុះហត្ថលេខាលើស្គ្រីប សូមដំណើរការវាតាមរយៈ JSLint ដើម្បីប្រាកដថាអ្នកមិនបានប្រព្រឹត្តកំហុសណាមួយឡើយ។
6. ស្គ្រីបគួរតែត្រូវបានដាក់នៅខាងក្រោមទំព័ររបស់អ្នក។
គោលបំណងចម្បងរបស់អ្នកប្រើប្រាស់គឺដើម្បីឱ្យទំព័រផ្ទុកលឿនតាមដែលអាចធ្វើទៅបាន។ កម្មវិធីរុករកមិនអាចបន្តផ្ទុកស្គ្រីបបានទេ រហូតដល់ឯកសារពេញលេញត្រូវបានផ្ទុក។ ជាលទ្ធផល អ្នកប្រើប្រាស់នឹងត្រូវរង់ចាំយូរជាងនេះ ដើម្បីមើលការវិវឌ្ឍន៍ណាមួយ។
ប្រសិនបើអ្នកមានឯកសារ JS ដែលត្រូវបានប្រើដើម្បីផ្តល់មុខងារតែប៉ុណ្ណោះ (ឧទាហរណ៍ នៅពេលដែលប៊ូតុងមួយត្រូវបានចុច) ដាក់វានៅខាងក្រោមនៃទំព័រ នៅពីមុខស្លាកតួបិទ។ នេះពិតជាការអនុវត្តល្អបំផុត
7. វិធីលឿនបំផុតដើម្បីធ្វើខ្សែអក្សរ
នៅពេលដែលអ្នកត្រូវការរង្វិលជុំជុំវិញអារេ ឬវត្ថុ កុំប្រើការទុកចិត្តរបស់អ្នកសម្រាប់ loop statement ជានិច្ច។ ប្រើការស្រមើស្រមៃរបស់អ្នក ដើម្បីស្វែងរកដំណោះស្រាយលឿនបំផុតសម្រាប់កិច្ចការដែលនៅនឹងដៃ។ ខ្ញុំនឹងមិននាំលេខមកអ្នកទេ។ អ្នកនឹងត្រូវជឿជាក់លើខ្ញុំ (ឬសាកល្បងដោយខ្លួនឯង)។
នេះគឺជាបច្ចេកទេសលឿនបំផុតមកដល់ពេលនេះ។
8. បន្ថែមមតិយោបល់ទៅលេខកូដរបស់អ្នក។
វាអាចហាក់ដូចជាគ្មានន័យនៅពេលដំបូង ប៉ុន្តែជឿខ្ញុំនៅពេលខ្ញុំនិយាយថាអ្នកគួរតែបញ្ចេញមតិលើកូដរបស់អ្នកឱ្យបានញឹកញាប់តាមដែលអាចធ្វើទៅបាន។ ចុះបើអ្នកត្រឡប់មកគម្រោងប៉ុន្មានខែក្រោយមក ហើយមិនអាចនឹកឃើញពីដំណើរការគិតដើមរបស់អ្នក?
ចុះបើលេខកូដរបស់អ្នកត្រូវអាប់ដេតដោយមិត្តរួមការងារម្នាក់របស់អ្នក? ផ្នែកសំខាន់ៗនៃកូដរបស់អ្នកគួរតែត្រូវបានផ្តល់យោបល់ជានិច្ច។
9. ប្រើអក្សរពុម្ពគំរូ
ឧបសគ្គនៃខ្សែអក្សរដែលបង្កើតដោយសញ្ញាសម្រង់ទ្វេ ឬមួយមានច្រើន។ ដើម្បីធ្វើឱ្យការធ្វើការជាមួយពួកគេកាន់តែងាយស្រួល អ្នកអាចជ្រើសរើសជំនួសខ្សែអក្សរមួយចំនួនរបស់អ្នកដោយអក្សរពុម្ព។
តួអក្សរ backtick (') ត្រូវបានប្រើសម្រាប់បង្កើតព្យញ្ជនៈគំរូដែលមានគុណសម្បត្តិមួយចំនួន។ អ្នកអាចប្រើពួកវាដើម្បីរក្សាទុកកន្សោម ឬដើម្បីបង្កើតខ្សែអក្សរច្រើនជួរ។
ដូចដែលអ្នកអាចមើលឃើញ មិនដូចខ្សែអក្សរធម្មតាដែលបង្កើតដោយសម្រង់តែមួយ ឬពីរដងទេ យើងមិនចាំបាច់ចូល និងចេញពីគំរូរបស់យើងម្តងហើយម្តងទៀតទេ។ វាកាត់បន្ថយលទ្ធភាពនៃការវាយបញ្ចូលកំហុស និងអនុញ្ញាតឱ្យយើងសរសេរកូដកាន់តែស្អាត។
10. Iterators និងសម្រាប់ ... នៃ Loops
Iterators គឺជាវត្ថុនៅក្នុង JavaScript ដែលអនុវត្តវិធីសាស្ត្របន្ទាប់ () ដើម្បីត្រឡប់វត្ថុដែលរក្សាទុកតម្លៃបន្ទាប់ក្នុងលំដាប់មួយ ក៏ដូចជាពិត ឬមិនពិត អាស្រ័យលើថាតើមានតម្លៃនៅសល់ទៀតទេ។ នេះមានន័យថា ប្រសិនបើអ្នកអនុវត្តពិធីការ iterator អ្នកអាចបង្កើតវត្ថុ iterator ផ្ទាល់ខ្លួនរបស់អ្នក។
មានឧបករណ៍បំប្លែងដែលបានបង្កើតឡើងក្នុង JavaScript ដូចជា String, Array, Map ជាដើម។ អ្នកអាចប្រើសម្រាប់ ... នៃរង្វិលជុំដើម្បីធ្វើឡើងវិញនៅទូទាំងពួកវា។ បើប្រៀបធៀបទៅនឹងរង្វិលជុំធម្មតា នេះគឺមានភាពសង្ខេប និងមិនសូវមានកំហុស។ យើងមិនចាំបាច់តាមដានប្រវែងពេញលេញនៃអារេ ឬលិបិក្រមបច្ចុប្បន្នដោយប្រើ for… of loop ទេ។ នៅពេលរចនារង្វិលជុំជាប់គ្នា វាអាចជួយសម្រួលកូដ។
11. ប្រើ {} ជំនួសឱ្យវត្ថុថ្មី ()
នៅក្នុង JavaScript អ្នកអាចបង្កើតវត្ថុតាមវិធីផ្សេងៗគ្នា។ ការប្រើប្រាស់ constructor ថ្មី ដូចដែលបានបង្ហាញ គឺជាវិធីសាមញ្ញជាង។ ម្យ៉ាងវិញទៀត យុទ្ធសាស្ត្រនេះត្រូវបានសម្គាល់ថាជា "ការអនុវត្តមិនល្អ"។
វាមិនមែនជាការបំផ្លិចបំផ្លាញទេ ប៉ុន្តែវាជាពាក្យតិចតួច និងប្លែក។ ខ្ញុំស្នើជំនួសវិញដោយប្រើបច្ចេកទេសព្យញ្ជនៈវត្ថុ។
12. ពិចារណាដាក់ let and const នៅក្នុងលេខកូដរបស់អ្នក។
យើងអាចប្រើពាក្យគន្លឹះអនុញ្ញាតដើម្បីបង្កើតអថេរមូលដ្ឋានដែលមានវិសាលភាពទៅនឹងប្លុករបស់ពួកគេ។ យើងអាចប្រើពាក្យគន្លឹះ const ដើម្បីបង្កើតអថេរប្លុកក្នុងតំបន់ដែលមិនអាចផ្លាស់ប្ដូរបាន។
នៅពេលប្រកាសអថេរ អ្នកគួរតែពិចារណាប្រើប្រាស់ពាក្យគន្លឹះ let and const នៅពេលដែលអាចអនុវត្តបាន។ សូមចងចាំថាពាក្យគន្លឹះ const បិទតែការចាត់តាំងឡើងវិញប៉ុណ្ណោះ។ វាមិនធ្វើឱ្យអថេរមិនអាចផ្លាស់ប្តូរបានទេ។
13. eval() មិនមែនជាគំនិតល្អទេ។
វិធីសាស្ត្រ eval() សម្រាប់អ្នកដែលមិនបានដឹង អនុញ្ញាតឱ្យយើងចូលទៅកាន់កម្មវិធីចងក្រងរបស់ JavaScript។ សំខាន់យើងអាចប្រើ eval ដើម្បីប្រតិបត្តិលទ្ធផលនៃ string ដោយផ្គត់ផ្គង់វាជា input ()។
វាមិនត្រឹមតែធ្វើឱ្យស្គ្រីបរបស់អ្នកថយចុះគួរឱ្យកត់សម្គាល់ប៉ុណ្ណោះទេ ប៉ុន្តែវាក៏ផ្តល់នូវការព្រួយបារម្ភអំពីសុវត្ថិភាពដ៏សំខាន់ផងដែរ ចាប់តាំងពីវាផ្តល់ឱ្យអត្ថបទដែលឆ្លងកាត់មានសិទ្ធិអំណាចខ្លាំងពេក។ ជៀសវាងវានៅគ្រប់ការចំណាយ!
14. Spread Operator មកយ៉ាងងាយស្រួល
តើអ្នកធ្លាប់ត្រូវការបញ្ជូនធាតុទាំងអស់នៅក្នុងអារេជាធាតុបុគ្គលទៅមុខងារមួយផ្សេងទៀត ឬតើអ្នកត្រូវដាក់តម្លៃទាំងអស់ពីអារេមួយទៅមួយទៀត? នេះគឺជាអ្វីដែលប្រតិបត្តិកររីករាលដាល (…) អនុញ្ញាតឱ្យយើងសម្រេចបាន។ នេះជារូបភាព។
15. រង់ចាំនិងធ្វើសមកាលកម្ម
បង្កើតមុខងារអសមកាលដោយប្រើពាក្យគន្លឹះ async ដែលតែងតែត្រឡប់ការសន្យា ដោយមិនច្បាស់លាស់ ឬដោយប្រយោល។
ពាក្យគន្លឹះរង់ចាំអាចត្រូវបានប្រើនៅក្នុងមុខងារអសមកាលដើម្បីបញ្ឈប់ការប្រតិបត្តិរហូតដល់ដំណោះស្រាយនៃការសន្យាត្រឡប់មកវិញត្រូវបានបញ្ចប់។ នៅខាងក្រៅមុខងារ async របស់អ្នក កូដនឹងបន្តដំណើរការធម្មតា។
16. ប្រើវិធីសាស្រ្ត include() ក្នុង Javascript
នៅក្នុង JavaScript មុខងារ include() កំណត់ថាតើខ្សែអក្សរមានតួអក្សរដែលបានផ្គត់ផ្គង់ ឬថាតើអារេមានធាតុដែលបានបញ្ជាក់។
វិធីសាស្ត្រនេះត្រឡប់ពិត ប្រសិនបើខ្សែអក្សរ ឬធាតុត្រូវបានរកឃើញ។ បើមិនដូច្នេះទេ វាត្រឡប់មិនពិត។ វាមានតម្លៃក្នុងការនិយាយថា អនុគមន៍ Strings មាន() គឺប្រកាន់អក្សរតូចធំ។ ប្រសិនបើអ្នកចង់ផ្គូផ្គងខ្សែអក្សរដោយមិនគិតពីករណីនោះទេ គ្រាន់តែដាក់អក្សរតូចទៅលើអត្ថបទគោលដៅជាមុនសិន។
17. យកធាតុចេញពីអារេដោយប្រើ Splice
ដើម្បីលុបធាតុចេញពីអារេ ខ្ញុំបានឃើញអ្នកអភិវឌ្ឍន៍ប្រើមុខងារលុប។ នេះគឺខុសព្រោះជាជាងលុបវត្ថុ វិធីសាស្ត្រលុបជំនួសវាដោយមិនបានកំណត់។
មធ្យោបាយងាយស្រួលបំផុតដើម្បីយកធាតុចេញពីអារេអាស្រ័យលើតម្លៃរបស់វានៅក្នុង JavaScript គឺត្រូវប្រើមុខងារ indexOf() ដើម្បីទទួលបានលេខលិបិក្រមនៃតម្លៃនោះក្នុងអារេ បន្ទាប់មកលុបតម្លៃលិបិក្រមនោះដោយប្រើវិធីសាស្ត្រ splice() ។.
18. ប្រើមុខងារព្រួញ
មុខងារព្រួញគឺជាមុខងារសំខាន់មួយទៀតដែលទើបតែត្រូវបានបន្ថែមទៅ JavaScript។
ពួកគេមានគុណសម្បត្តិទូក។ ដើម្បីចាប់ផ្តើម ពួកវាធ្វើឱ្យផ្នែកមុខងាររបស់ JavaScript កាន់តែទាក់ទាញ និងងាយស្រួលក្នុងការសរសេរ។ ទោះយ៉ាងណាក៏ដោយ ការប្រើមុខងារព្រួញធ្វើឱ្យវាកាន់តែច្បាស់ និងសង្ខេប។
19. ជាមួយនឹង Destructuring អ្នកអាចកំណត់តម្លៃអថេរបានយ៉ាងឆាប់រហ័ស
មុននេះនៅក្នុងប្រកាសនេះ យើងបានរៀនអំពីប្រតិបត្តិកររីករាលដាលនៅក្នុង JavaScript ។ ការបំផ្លិចបំផ្លាញគឺស្រដៀងនឹងការបំផ្លិចបំផ្លាញ ដែលវាក៏ពន្លាទិន្នន័យដែលមាននៅក្នុងអារេផងដែរ។
ភាពខុសគ្នាគឺថាតម្លៃដែលមិនបានវេចខ្ចប់ទាំងនេះអាចត្រូវបានកំណត់ទៅអថេរផ្សេងគ្នា។ វាក្យសម្ព័ន្ធគឺដូចគ្នាបេះបិទទៅនឹងផ្លូវកាត់ [] នៅពេលបង្កើតអារេ។ ទោះជាយ៉ាងណាក៏ដោយ តង្កៀបត្រូវបានដាក់នៅផ្នែកខាងឆ្វេងនៃប្រតិបត្តិករកិច្ចការនៅពេលនេះ។ នេះជារូបភាព។
20. បង្កើតគម្រោងជាច្រើន។
ទេពកោសល្យណាមួយត្រូវការការអនុវត្តជាប់លាប់ ដូច្នេះព្យាយាមបង្កើតគម្រោងផ្សេងៗ ដើម្បីពង្រឹងសមត្ថភាពរបស់អ្នក និងទទួលបានជំនាញជាមួយនឹងសេណារីយ៉ូកម្មវិធីផ្សេងៗ។
នៅពេលធ្វើការលើគម្រោង អ្នកនឹងជួបប្រទះបញ្ហាប្រឈម និងកំហុសជាច្រើន ដែលនឹងផ្តល់ឱ្យអ្នកនូវជំនាញចាំបាច់។ ដូច្នេះ សូមព្យាយាមបង្កើតគម្រោង ហើយមានគំនិត និងឧទាហរណ៍ជាច្រើននៅលើអ៊ីនធឺណិត ដើម្បីជួយអ្នក។ បន្តបង្កើតកូដ ហើយសមត្ថភាពរបស់អ្នកនឹងប្រសើរឡើង។
សន្និដ្ឋាន
វាប្រហែលជាពិបាកក្នុងការរៀនភាសាកុំព្យូទ័រដូចជា JavaScript។ ប្រសិនបើអ្នកយកចិត្តទុកដាក់ក្នុងការក្លាយជាអ្នកសរសេរកម្មវិធីដ៏ល្អ និងធានាបាននូវការងារដំបូងរបស់អ្នក នោះយុទ្ធសាស្ត្ររៀន JavaScript ទាំងនេះអាចជួយអ្នកបង្កើនល្បឿនដំណើរការសិក្សារបស់អ្នក។
ត្រូវប្រាកដថាអ្នកអនុវត្តការសរសេរកូដជាប្រចាំ កត់ត្រាឱ្យបានហ្មត់ចត់ ខណៈពេលកំពុងរៀនគំនិតថ្មីៗ និងប្រើប្រាស់ឧបករណ៍ទាំងអស់ដែលអាចចូលប្រើបាន។ សំខាន់ជាងនេះទៅទៀត សូមចេញពីទីនោះ ហើយចាប់ផ្តើមសរសេរកូដពេលកំពុងសប្បាយ។
សូមផ្ដល់យោបល់