អ្នកតែងតែចង់ទទួលបានចំណេះដឹងទូលំទូលាយនៅក្នុងវិស័យដែលអ្នកធ្វើការជាមួយ។ JavaScript គឺជាភាសាមួយក្នុងចំណោមភាសាដែលវាស្ទើរតែមិនអាចទទួលបានចំណេះដឹងទូលំទូលាយ។ វាមានការវិវឌ្ឍឥតឈប់ឈរ ក៏ដូចជាគេហទំព័រទូទៅដែរ ដូច្នេះអ្នកបង្កើតគេហទំព័រណាមួយគួរតែខិតខំបន្តជាមួយនឹងការអភិវឌ្ឍន៍នេះ ហើយលើសពីនេះទៅទៀត ត្រូវតែដឹងដោយបេះដូងនូវមូលដ្ឋានគ្រឹះនៃបច្ចេកវិទ្យាដែលគាត់កំពុងប្រើប្រាស់។

ពេលនេះ JavaScript គ្របដណ្តប់លើពិភពព័ត៌មានវិទ្យា។ ជាមួយវា អ្នកអាចបង្កើតកម្មវិធីបណ្តាញតូចមួយ ឬកម្មវិធីមនុស្សយន្ត។ ជាសំណាងល្អ ភាសាបានដំណើរការអស់មួយរយៈមកហើយ ហើយអ្នកអភិវឌ្ឍន៍ដែលបានស្ទាត់ជំនាញវាយ៉ាងល្អឥតខ្ចោះបានពិពណ៌នាបទពិសោធន៍របស់ពួកគេក្នុងការសរសេរកម្មវិធីនៅក្នុងសៀវភៅ។

សៀវភៅនេះប្រាប់អ្នកពីរបៀបធ្វើឱ្យកុំព្យូទ័រធ្វើអ្វីដែលអ្នកចង់ឱ្យពួកគេធ្វើ។ កុំព្យូទ័រសព្វថ្ងៃនេះគឺជារឿងធម្មតាដូចទួណឺវីស - ប៉ុន្តែមានភាពស្មុគស្មាញលាក់កំបាំងជាច្រើនទៀត ដូច្នេះហើយពិបាកយល់ និងដំណើរការ។ សម្រាប់មនុស្សជាច្រើន ពួកគេនៅតែជាជនបរទេស ដែលគំរាមកំហែងបន្តិចបន្តួច។ សៀវភៅនេះក៏មានជាភាសារុស្សីផងដែរ។

សៀវភៅនេះផ្តល់នូវទិដ្ឋភាពទូទៅយ៉ាងហ្មត់ចត់នៃពិភពលោកនៃ JavaScript តាមរយៈវត្ថុដែលភ្ជាប់មកជាមួយ និងភាពខុសគ្នានៃភាសា។ សៀវភៅនេះពិតជាមិនមានបំណងសម្រាប់អ្នកដែលទើបតែចាប់ផ្តើមរៀនសរសេរកម្មវិធីជាទូទៅ និង JavaScript ជាពិសេសនោះទេ។

សៀវភៅនេះគ្របដណ្តប់ទាំងលំនាំសរសេរកម្មវិធី JavaScript បុរាណ និងទំនើប។ ជាទូទៅ វាមានគោលបំណងសម្រាប់អ្នកសរសេរកម្មវិធីដែលចាប់ផ្តើមដំបូង។

HTML5 ផ្តល់ឱកាសដ៏អស្ចារ្យ។ jQuery ក៏ដូចគ្នាដែរ។ ដូច Node.JS. ប្រសិនបើអ្នកបន្ថែម JavaScript ដ៏បរិសុទ្ធបន្តិចទៅពួកវា អ្នកអាចយកឈ្នះគេហទំព័របានយ៉ាងងាយស្រួល។

សៀវភៅនេះត្រូវបានបម្រុងទុកសម្រាប់អ្នកដែលមានគម្រោងបង្កើតកម្មវិធីគេហទំព័រដោយប្រើ JS ។ វាពិពណ៌នាអំពីលក្ខណៈពិសេសនៃភាសា ឧបករណ៍មានប្រយោជន៍ គំរូ ហើយបញ្ជីមិនត្រូវបានកំណត់ចំពោះរឿងនេះទេ។

សៀវភៅនេះនឹងផ្តល់ឱ្យអ្នកនូវចំណេះដឹងទូទៅនៃ JavaScript ដោយយល់ទាំងតក្កវិជ្ជាទូទៅ និងព័ត៌មានលម្អិតរបស់វា។ អ្នកនិពន្ធសន្មត់ថាអ្នកអានបានស្គាល់រួចហើយនូវគោលការណ៍នៃកម្មវិធីតម្រង់ទិសវត្ថុ និងភាសាដូចជា PHP, Ruby, Python, C++ ឬ Java ។

តើអ្នកត្រៀមខ្លួនរួចជាស្រេចដើម្បីអនុវត្តការសរសេរកម្មវិធីគេហទំព័ររបស់អ្នកមួយជំហានបន្ថែមទៀត ហើយផ្លាស់ទីពីការសរសេរកូដនៅក្នុង HTML និង CSS ទៅជាការបង្កើតទំព័រថាមវន្តពេញលេញដែរឬទេ? ដល់​ពេល​ស្គាល់​ភាសា​សរសេរ​កម្មវិធី​ដែល​ក្តៅ​បំផុត - JavaScript!

បន្ទាប់ពីអានសៀវភៅនេះ អ្នកនឹងរៀនអ្វីគ្រប់យ៉ាងអំពីភាសា JavaScript៖ ពីអថេរទៅរង្វិលជុំ។ អ្នក​នឹង​យល់​ថា​ហេតុ​អ្វី​បាន​ជា​ browser ផ្សេង​គ្នា​ឆ្លើយ​តប​ទៅ​នឹង​កូដ​ខុស​គ្នា និង​របៀប​សរសេរ​កូដ​សកល​ដែល​ត្រូវ​បាន​គាំទ្រ​ដោយ​គ្រប់ browsers។ អ្នកនឹងយល់ពីមូលហេតុដែល JS គឺជាអនាគត ហើយក្លាយជាអ្នកអភិវឌ្ឍន៍ផ្នែកខាងមុខពិតប្រាកដ។

សៀវភៅនេះបង្ហាញអ្នកពីរបៀបសរសេរកម្មវិធីផ្នែកខាងមុខនៅក្នុង JS ដោយមិនប្រើក្របខ័ណ្ឌភាគីទីបី ឬបណ្ណាល័យណាមួយឡើយ។

បន្ថែមពីលើចំណេះដឹងទូទៅនៃគោលការណ៍ JavaScript សៀវភៅនេះក៏នឹងផ្តល់ឱ្យអ្នកនូវចំណេះដឹងអំពីផ្នែកដែលពាក់ព័ន្ធដូចជា JSON ឬ NoSQL ក៏ដូចជាការយល់ដឹងអំពីរបៀបដែលកម្មវិធីគេហទំព័រត្រូវបានសរសេរជាទូទៅ។

ដូចដែលចំណងជើងបានបង្ហាញ សៀវភៅនេះនិយាយអំពីការបង្កើតកម្មវិធីទំព័រតែមួយ។ វាមិនពិពណ៌នាអំពីបច្ចេកវិជ្ជា និងក្របខ័ណ្ឌជាក់លាក់ទេ ប៉ុន្តែវាពិពណ៌នាអំពីគំរូ និងការអនុវត្តទូទៅបានយ៉ាងល្អ។

សៀវភៅនេះត្រូវបានឧទ្ទិសដល់ការធ្វើការជាមួយ DOM (Document Object Model) - ប្រហែលជារឿងសំខាន់បំផុតនៅក្នុង JavaScript សម្រាប់អ្នកបង្កើតគេហទំព័រទាំងអស់។

សៀវភៅនេះសរសេរដោយ Douglas Crockford ដែលជាអ្នកបង្កើត JSON និង JSLint គឺជាសៀវភៅបុរាណនៅក្នុងពិភព JavaScript ដែលគ្រប់គ្នាគួរតែអាន។ វាគ្របដណ្តប់មូលដ្ឋាននៃវិធីសាស្រ្តតម្រង់ទិសវត្ថុ និងផ្តល់នូវឧទាហរណ៍ជាច្រើន ទាំងល្អ និងអាក្រក់។ ជាការពិតណាស់ អ្នកនិពន្ធប្រាប់ពីរបៀបកែឧទាហរណ៍ "គ្រោះថ្នាក់" បែបនេះ និងវិធីជៀសវាងកំហុសបែបនេះ។

ស៊េរីនេះសរសេរដោយគ្រូល្បីឈ្មោះ Kyle Simpson មានសៀវភៅចំនួន 6 ក្បាល ដែលនីមួយៗមានផ្នែកផ្សេងៗនៃភាសា។ អត្ថប្រយោជន៍ចម្បងនៃសៀវភៅទាំងនេះ គឺវាខ្លីគ្រប់គ្រាន់ ដូច្នេះអ្នកនឹងមិនមានពេលវេលាដើម្បីរំខាន។ ហើយអ្នកអាចទិញសៀវភៅ “ES6 and Beyond” ពីស៊េរីនេះជាក្រដាសជាភាសារុស្សី។

JavaScript គឺជាឧបករណ៍ចម្បងរបស់អ្នកបង្កើតគេហទំព័រដែលអនុញ្ញាតឱ្យអ្នកធ្វើឱ្យទំព័រអ៊ីនធឺណិតមានអន្តរកម្ម ថាមវន្ត និងសម្រេចបាននូវដំណើរការខ្ពស់បំផុត។ នេះគឺជាការណែនាំដែលមានរចនាសម្ព័ន្ធល្អចំពោះ JavaScript ដែលនឹងអនុញ្ញាតឱ្យអ្នករៀនយ៉ាងឆាប់រហ័ស មិនមែនជាភាសាដែលងាយស្រួលបំផុតក្នុងការរៀននោះទេ ប៉ុន្តែជាភាសាដែលពេញនិយមបំផុត។ ការយកចិត្តទុកដាក់ជាច្រើនត្រូវបានបង់ទៅបណ្ណាល័យ jQuery នៅក្នុងសៀវភៅ។ វាក៏មានឧទាហរណ៍ជាច្រើន និងកិច្ចការលម្អិតផងដែរ។

បន្ទាប់ពីអានការណែនាំដ៏ទូលំទូលាយ អ្នកនឹងអាច៖

• ធ្វើឱ្យទំព័រគេហទំព័ររបស់អ្នកមានអន្តរកម្ម។
• គ្រប់គ្រងកំណែចុងក្រោយបំផុតនៃកម្មវិធីជំនួយ jQuery UI ។
• បង្កើតទម្រង់ងាយស្រួលជាមួយនឹងសុពលភាពទិន្នន័យ និងការកែតម្រូវដោយស្វ័យប្រវត្តិ។
• ប្រើបច្ចេកវិទ្យា AJAX ។
• ពង្រឹងចំណេះដឹងរបស់អ្នកក្នុងវិស័យនេះ និងក្លាយជាអ្នកជំនាញ។

បន្ទាប់ពីសិក្សាពីមូលដ្ឋានគ្រឹះនៃប្លង់ អ្នកប្រាកដជាចង់បានអន្តរកម្ម និងភាពស្រស់ស្អាតជាងមុន ក៏ដូចជាមធ្យោបាយងាយស្រួលបន្ថែមទៀតសម្រាប់គេហទំព័រដើម្បីធ្វើអន្តរកម្មជាមួយផ្នែកខាងក្រោយ។ នោះហើយជាពេលដែល JavaScript ចូលទៅក្នុងឆាករួមជាមួយនឹងក្របខ័ណ្ឌ jQuery ដ៏ពេញនិយម។ ដើម្បីចាប់ផ្តើមធ្វើការជាមួយសៀវភៅ អ្នកមិនត្រូវការចំណេះដឹងជ្រៅជ្រះទេ - អ្នកនឹងទទួលបានវាទាំងអស់ពីវា។ មានតែការអនុវត្តចុងក្រោយបង្អស់ក្នុងវិស័យភាពឆបគ្នានៃកម្មវិធីរុករកតាមអ៊ីនធឺណិត និងការបង្កើនប្រសិទ្ធភាពទំព័រប៉ុណ្ណោះដែលត្រូវបានបង្ហាញនៅទីនេះ ហើយបទបង្ហាញជាភាសាច្បាស់លាស់ជាមួយនឹងឧទាហរណ៍ និងរូបភាពច្បាស់លាស់។

សៀវភៅដែលបានក្លាយជាសៀវភៅបុរាណរួចហើយ។ ការបោះពុម្ពចុងក្រោយបំផុតរបស់វាគ្របដណ្តប់ HTML5 និង ECMAScript 6 - បច្ចេកវិទ្យាដែលពាក់ព័ន្ធបំផុតនាពេលបច្ចុប្បន្ននេះ។ វាក៏បន្ថែមជំពូកថ្មីនៅលើ jQuery និង JavaScript ចំហៀងម៉ាស៊ីនមេ។ មគ្គុទ្ទេសក៍នេះនឹងមានប្រយោជន៍សម្រាប់អ្នកចាប់ផ្តើមដំបូង និងអ្នកដែលចង់ពង្រឹងចំណេះដឹងរបស់ពួកគេអំពី JavaScript ឱ្យមានភាពល្អឥតខ្ចោះ។

ការបកប្រែដោយសម្របខ្លួននៃអត្ថបទ "JavaScript ពេញលេញក្នុងរយៈពេលប្រាំមួយសប្តាហ៍: មគ្គុទ្ទេសក៍កម្មវិធីសិក្សា"

ការអភិវឌ្ឍន៍គេហទំព័រគឺជាផ្នែកមួយដ៏សាមញ្ញបំផុត ហើយជាផ្នែកពេញនិយមក្នុងចំណោមអ្នកសរសេរកម្មវិធីថ្មីថ្មោង។ កម្មវិធីនិពន្ធអត្ថបទ និងកម្មវិធីរុករកណាមួយគឺគ្រប់គ្រាន់ដើម្បីធ្វើការ មិនចាំបាច់សិក្សាក្បួនដោះស្រាយនៅកម្រិតកម្រិតខ្ពស់នោះទេ លទ្ធផលនៃដំណាក់កាលនីមួយៗនៃការសរសេរកម្មវិធីគឺច្បាស់ណាស់ - ជាទូទៅវាមានអត្ថប្រយោជន៍ជាច្រើន។ ជំនាញសំខាន់នៅក្នុងបរិបទនៃការអភិវឌ្ឍន៍គេហទំព័រគឺចំណេះដឹងអំពី JavaScript ។

សព្វថ្ងៃនេះ JavaScript កំពុងអភិវឌ្ឍយ៉ាងឆាប់រហ័ស ដូច្នេះវាងាយស្រួលក្នុងការយល់ច្រលំនៅពេលរៀនភាសា។ យើងផ្តល់ជូនអ្នកនូវកម្មវិធីសិក្សាដែលមានរចនាសម្ព័ន្ធល្អ ដែលគ្របដណ្តប់គ្រប់ទិដ្ឋភាពសំខាន់ៗនៃ JavaScript និងបច្ចេកវិទ្យាដែលពាក់ព័ន្ធ។

ហេតុអ្វី JavaScript?

វាគួរឱ្យកត់សម្គាល់ពីភាពបើកចំហនៃភាសា - ក្រុមហ៊ុនដែលជាធម្មតាប្រកួតប្រជែងគ្នាកំពុងសហការគ្នាដើម្បីបង្កើត JavaScript ។ ភាសាមានភាពបត់បែនខ្លាំង ហើយនឹងសមនឹងអ្នកគាំទ្រទាំងវិធីសាស្រ្តតម្រង់ទិសវត្ថុ និងមុខងារ។ បណ្ណាល័យ និងក្របខ័ណ្ឌមួយចំនួនធំធ្វើឱ្យវាងាយស្រួលក្នុងការដោះស្រាយបញ្ហាគ្រប់ប្រភេទ ហើយវេទិកាម៉ាស៊ីនមេ Node.js ធ្វើឱ្យវាអាចប្រើភាសាមិនត្រឹមតែនៅក្នុងកម្មវិធីរុករកប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងនៅក្នុងកុងសូលផងដែរ។ អ្នកថែមទាំងអាចសរសេរកម្មវិធីលើតុ និងទូរស័ព្ទបាន៖ ពីមុនប្រើក្របខណ្ឌ Electron ហើយក្រោយមកទៀតប្រើ NativeScript ឬ React Native។

មូលដ្ឋាន

ដំបូងអ្នកត្រូវរៀនគោលគំនិតជាមូលដ្ឋាននៃ JavaScript ការអភិវឌ្ឍន៍គេហទំព័រ និងការសរសេរកម្មវិធីជាទូទៅ៖

• JS តម្រង់ទិសវត្ថុ - អ្នកសាងសង់និងរោងចក្រ មរតក;
• មុខងារ JS - មុខងារលំដាប់ខ្ពស់ ការបិទ ការហៅឡើងវិញ;
• លក្ខណៈបច្ចេកទេសនៃការធ្វើតេស្តផ្កាម្លិះ;
• មូលដ្ឋានគ្រឹះនៃ HTML, CSS និង jQuery ។

ហ្គីត

Git គឺជាឧបករណ៍សំខាន់សម្រាប់អ្នកអភិវឌ្ឍន៍ ដូច្នេះចាប់ផ្តើមជាមួយវាឱ្យបានឆាប់តាមដែលអាចធ្វើទៅបាន។ នេះជាជំនាញមូលដ្ឋានដែលអ្នកគួរមាន៖

• ការបង្កើតនិងផ្លាស់ទីឯកសារនៅក្នុងថត;
• ការចាប់ផ្តើមនិងការប្តេជ្ញាចិត្តនៅក្នុង Git;
• ការដំឡើងឃ្លាំងនៅក្នុង GitHub ។

ក្បួនដោះស្រាយ និងរចនាសម្ព័ន្ធទិន្នន័យ

បន្ទាប់មកទៀត វាមានតម្លៃសិក្សាអំពីក្បួនដោះស្រាយ (ជាពិសេស គំនិតនៃភាពស្មុគស្មាញនៃក្បួនដោះស្រាយ) ក៏ដូចជារចនាសម្ព័ន្ធទិន្នន័យមូលដ្ឋាន៖ បញ្ជីដែលបានភ្ជាប់ ជួរ ជង់ ដើមឈើស្វែងរកប្រព័ន្ធគោលពីរ និងតារាងសញ្ញា។ នេះនឹងជួយអ្នក។

BackendNode.js

កាលពី 10 ឆ្នាំមុន JavaScript អាចប្រើបានសម្រាប់តែការអភិវឌ្ឍន៍ផ្នែកខាងមុខប៉ុណ្ណោះ។ ឥឡូវនេះ សូមអរគុណដល់ Node.js បញ្ហាមិនត្រូវបានកំណត់ចំពោះ "ផ្នែកខាងមុខ" មួយទេ។ Node គឺគ្រាន់តែជាបរិយាកាសសម្រាប់ដំណើរការកូដ JS នៅផ្នែកខាងម៉ាស៊ីនមេ ដូច្នេះអ្នកនឹងមិនចាំបាច់រៀនវាក្យសម្ព័ន្ធថ្មីទេ ប៉ុន្តែអ្នកនឹងត្រូវនាំចូល និងនាំចេញឯកសារ កែប្រែកូដ និងប្រើកម្មវិធីគ្រប់គ្រងកញ្ចប់ npm ។

ម៉ាស៊ីនមេ HTTP, Express.js

បន្ទាប់ពីរៀន Node វាពិតជាមានតម្លៃក្នុងការបន្តការស្គាល់របស់អ្នកជាមួយនឹងការអភិវឌ្ឍន៍ backend និងការយល់ដឹងអំពី servers និង routing។ អ្នកអាចចាប់ផ្តើមជាមួយច្រក និងពិធីការដោយសង្កត់ធ្ងន់លើ HTTP ហើយបន្ទាប់មកបន្តទៅ Express ដែលជាបណ្ណាល័យ Node សម្រាប់ដំណើរការសំណើ។

មូលដ្ឋានទិន្នន័យ JavaScript អសមកាល គ្រោងការណ៍ គំរូ និង ORMs

មូលដ្ឋានទិន្នន័យគឺជាធាតុសំខាន់បំផុតមួយនៃការអភិវឌ្ឍន៍គេហទំព័រ។ ប្រសិនបើកម្មវិធីរបស់អ្នកត្រូវការផ្ទុក ឬរក្សាទុកទិន្នន័យណាមួយដែលមិនបាត់បង់នៅពេលដែលទំព័រត្រូវបានធ្វើឱ្យស្រស់ អ្នកនឹងត្រូវប្រើមូលដ្ឋានទិន្នន័យ។ អ្នក​ត្រូវ​រៀន​បែងចែក​រវាង​មូលដ្ឋាន​ទិន្នន័យ​ទំនាក់​ទំនង​និង​មិន​ទំនាក់​ទំនង ហើយ​យល់​ពី​ប្រភេទ​នៃ​ទំនាក់ទំនង។ បន្ទាប់មកស្គាល់មនុស្សផ្សេងគ្នា។ សមត្ថភាពក្នុងការធ្វើការជាមួយ ORM ក៏នឹងមិននាំអោយ។

FrontendHTML និង CSS

HTML និង CSS គឺជាមូលដ្ឋានគ្រឹះរបស់អ្នកអភិវឌ្ឍន៍គេហទំព័រណាមួយ។ អ្នកមិនចាំបាច់ស្គាល់ពួកគេច្បាស់ទេ ប៉ុន្តែអ្នកគួរតែយល់ពីពួកគេ។ អ្នកក៏អាចរុករកបណ្ណាល័យដ៏ពេញនិយមមួយ (ឧទាហរណ៍ Bootstrap) និង CSS preprocessor ដូចជា Sass - វានឹងជួយធ្វើឱ្យ CSS មើលទៅដូចកូដធម្មតា។ ដើម្បីសម្រួលការងារជាមួយ HTML អ្នកអាចជ្រើសរើសម៉ាស៊ីនគំរូដ៏ពេញនិយមមួយ ឧទាហរណ៍ pug ។

jQuery និង DOM រៀបចំ

នៅពេលដែលអ្នកបានបង្កើតរូបរាង និងអារម្មណ៍នៃទំព័ររបស់អ្នកដោយប្រើ HTML និង CSS អ្នកក៏នឹងប្រើ jQuery ដើម្បីរៀបចំ DOM ផងដែរ។ មនុស្សជាច្រើនគិតថា jQuery គឺគ្មានប្រយោជន៍ ហើយឆាប់ៗនេះនឹងត្រូវជំនួសដោយ Angular និង React ប៉ុន្តែវាមានប្រជាប្រិយភាពខ្លាំងមែនទែន ដូច្នេះហើយគួរដឹង។ លើសពីនេះ ថ្ងៃណាមួយអ្នកនឹងឃើញខ្លួនអ្នកនៅក្នុងស្ថានភាពមួយដែលវានឹងមានការរអាក់រអួលសម្រាប់អ្នកក្នុងការញញួរក្រចកដោយប្រើមីក្រូទស្សន៍ React ហើយបន្ទាប់មក jQuery ទម្ងន់ស្រាលនឹងមកជួយអ្នក។

ឧបករណ៍អ្នកអភិវឌ្ឍន៍ Chrome

វាមិនអាចអត់ឱនឱ្យបានទេក្នុងការធ្វេសប្រហែសឧបករណ៍ Chrome ដែលផ្តល់នូវលទ្ធភាពយ៉ាងច្រើន។ ជាមួយពួកគេ អ្នកអាចពិនិត្យមើលធាតុ DOM បំបាត់កំហុសតាមរយៈកុងសូល ផ្លូវតាមដាន និងច្រើនទៀត។ យើងពណ៌នាអំពីមុខងារងាយស្រួលជាច្រើននៃកុងសូល Chrome ដែលនឹងធ្វើឱ្យកិច្ចការប្រចាំថ្ងៃកាន់តែងាយស្រួល។

AJAX

ប្រសិនបើអ្នកចង់ឱ្យកម្មវិធីរបស់អ្នកមិនផ្ទុកទំព័រឡើងវិញបន្ទាប់ពីរាល់ប្រតិបត្តិការមូលដ្ឋានទិន្នន័យ អ្នកប្រាកដជាត្រូវការ AJAX - វាផ្ញើសំណើ HTTP អសមកាលផ្ទៃខាងក្រោយ ដែលជាការឆ្លើយតបដែលគ្រាន់តែធ្វើបច្ចុប្បន្នភាពផ្នែកនៃការបង្ហាញប៉ុណ្ណោះ។ អ្នកអាចធ្វើការជាមួយ AJAX តាមរយៈ jQuery ដោយប្រើវិធីសាស្ត្រ .ajax ។

ប្រធានបទកម្រិតខ្ពស់សាកល្បងការអភិវឌ្ឍន៍

ឬ TDD គឺជាបច្ចេកទេសអភិវឌ្ឍន៍ដែលការបង្កើតកម្មវិធីត្រូវបានបែងចែកទៅជាវដ្តតូចៗជាច្រើន៖ ដំបូង ការធ្វើតេស្តត្រូវបានសរសេរដែលគ្របដណ្តប់ការផ្លាស់ប្តូរដែលចង់បាន បន្ទាប់មកកូដត្រូវបានសរសេរដែលឆ្លងកាត់ការសាកល្បងទាំងនេះ។ បន្ទាប់ពីនេះ កូដត្រូវបានជួសជុលឡើងវិញ ហើយការធ្វើតេស្តថ្មីត្រូវបានសរសេរប្រសិនបើចាំបាច់។ ប្រសិនបើផ្នែកនៃកូដបរាជ័យការធ្វើតេស្តមួយចំនួន វាត្រូវបានកែដំរូវ។

រន្ធបណ្តាញ

ប្រធានបទនេះគឺគួរអោយយកចិត្តទុកដាក់ជាពិសេសព្រោះវាមានប្រយោជន៍ណាស់។ ពិធីការ WebSocket មិនដូច HTTP អនុញ្ញាតឱ្យមានលំហូរទិន្នន័យទ្វេទិស ដែលធ្វើឱ្យបច្ចេកវិទ្យានេះមានតែមួយគត់។ ការអនុវត្តទូទៅបំផុតគឺបណ្ណាល័យ socket.io - ការយល់ដឹងពីវា និងការអនុវត្តជំនាញដែលទទួលបានក្នុងការអនុវត្តនឹងជួយអ្នកបង្កើតហ្គេមកម្មវិធីរុករកដែលមានអ្នកលេងច្រើន។

ES6, Babel, Webpack

បច្ចុប្បន្ន ស្តង់ដារសំខាន់គឺ ES6 (ES2015) ប៉ុន្តែ ES2016 ត្រូវបានអនុម័តរួចហើយ ហើយ ES2017 កំពុងស្ថិតក្នុងការអភិវឌ្ឍន៍ ដូច្នេះអ្នកត្រូវដឹងអំពីបច្ចុប្បន្នភាព និងប្រើប្រាស់ពួកវាជានិច្ច។ បញ្ហាភាពឆបគ្នាអាចត្រូវបានដោះស្រាយដោយគ្រាន់តែឧបករណ៍មួយចំនួន៖

• Babel - ចងក្រងកូដ ES6 (ការគាំទ្រ ES2016 នឹងមកដល់ឆាប់ៗនេះ) ទៅ ES5 ដែលត្រូវបានគាំទ្រដោយកម្មវិធីរុករកទាំងអស់។ វាថែមទាំងដឹងពីរបៀបចងក្រងសមាសធាតុ JSX/React ដែលធ្វើឱ្យវាមិនអាចខ្វះបានសម្រាប់អ្នកបង្កើតគេហទំព័រណាមួយ។
• Webpack - ប្រមូលឯកសារប្រភពរបស់អ្នកទាំងអស់ (រូបភាព ពុម្ពអក្សរ សន្លឹករចនាប័ទ្ម ឯកសារ JS ។ល។) ទៅក្នុងក្រាហ្វអាស្រ័យតែមួយ។ វានឹងមិនមានប្រយោជន៍នៅពេលបង្កើតកម្មវិធីតូចៗ ប៉ុន្តែនៅពេលធ្វើការជាមួយ React ជំនួយរបស់វាមានតម្លៃមិនអាចកាត់ថ្លៃបាន។

ប្រតិកម្ម និង Redux

React គឺជាបណ្ណាល័យសម្រាប់បង្កើតចំណុចប្រទាក់អ្នកប្រើប្រាស់។ វាត្រូវបានបង្កើតឡើងដោយ Facebook ក្នុងឆ្នាំ 2013 ហើយបានក្លាយជាការពេញនិយមយ៉ាងឆាប់រហ័សក្នុងចំណោមអ្នកអភិវឌ្ឍន៍។ អ្នក​គួរ​តែ​អាន រួច​ផ្តាច់​ចេញ​ដើម្បី​យល់​ពី​របៀប​ដែល React ដំណើរការ និង​អ្វី​ដែល​វា​ធ្វើ។ React មានប្រយោជន៍មិនត្រឹមតែសម្រាប់ការអភិវឌ្ឍន៍ផ្នែកខាងមុខប៉ុណ្ណោះទេ៖ Facebook បានចេញផ្សាយកំណែនៃក្របខ័ណ្ឌសម្រាប់ទូរស័ព្ទ (React Native) និងការអភិវឌ្ឍន៍ VR (React VR) ។

Redux គឺជាកុងតឺន័ររដ្ឋដែលអាចទស្សន៍ទាយបានដែលត្រូវបានប្រើប្រាស់ជាទូទៅក្នុងការភ្ជាប់ជាមួយ React ។ វាអាចត្រូវបានប្រើដើម្បីកាត់បន្ថយកូដដោយសារតែម៉ូឌុលរបស់វា។ មានប្រយោជន៍ជាពិសេសនៅក្នុងពេលវេលាពិត និងកម្មវិធីដែលមានអ្នកប្រើប្រាស់ច្រើនដូចជាហ្គេមជាដើម។

ការផ្ទៀងផ្ទាត់ភាពត្រឹមត្រូវ វគ្គ ខូគី

អ្នកក៏គួរតែយល់ពីរបៀបដែលកម្មវិធីមានអន្តរកម្មជាមួយអ្នកប្រើប្រាស់ ដំណើរការគណនីចូល និងចេញពីគណនី និងការចេញសិទ្ធិ។ ដើម្បីតាមដានអត្តសញ្ញាណរបស់អ្នកប្រើក្នុងអំឡុងពេលសម័យមួយ ខូគីត្រូវបានប្រើ - ឯកសារអត្ថបទតូចៗដែលផ្ញើដោយម៉ាស៊ីនមេទៅកម្មវិធីរុករកតាមអ៊ីនធឺណិតដើម្បីឆ្លើយតបទៅនឹងសំណើ HTTP ។ ហើយ​ដើម្បី​ធានា​បាន​នូវ​ការ​តភ្ជាប់​រវាង​មូលដ្ឋាន​ទិន្នន័យ​និង​ទំព័រ​អនុញ្ញាត​ អ្នក​អាច​ប្រើ​បណ្ណាល័យ​សម័យ​បញ្ចេញមតិ។

សុវត្ថិភាពគេហទំព័រ

ហើយចុងក្រោយ អ្នកគួរតែយកចិត្តទុកដាក់លើសុវត្ថិភាព។ វាមានសារៈសំខាន់ណាស់ក្នុងការរៀនទាំងវិធីសាស្ត្រវាយប្រហារ និងវិធីការពារប្រឆាំងនឹងពួកគេ។

• ការបកប្រែ

សម្ភារៈ ដែលជាការបកប្រែដែលយើងកំពុងបោះផ្សាយថ្ងៃនេះ គឺត្រូវបានឧទ្ទិសដល់មូលដ្ឋាននៃ JavaScript និងត្រូវបានបម្រុងទុកសម្រាប់អ្នកសរសេរកម្មវិធីដែលចាប់ផ្តើមដំបូង។ វាក៏អាចត្រូវបានចាត់ទុកថាជាសៀវភៅយោងតូចមួយលើការសាងសង់ JS មូលដ្ឋាន។ នៅទីនេះ ជាពិសេសយើងនឹងនិយាយអំពីប្រព័ន្ធប្រភេទទិន្នន័យ អថេរ អារេ មុខងារ គំរូវត្ថុ និងលក្ខណៈពិសេសមួយចំនួនផ្សេងទៀតនៃភាសា។

ប្រភេទទិន្នន័យបឋម JavaScript មានប្រភេទទិន្នន័យបឋមដូចខាងក្រោម៖ លេខ ប៊ូលីន ខ្សែអក្សរ មិនបានកំណត់ ទុកជាមោឃៈ។ វាគួរតែត្រូវបានកត់សម្គាល់ភ្លាមៗថា នៅពេលធ្វើការជាមួយប្រភេទទិន្នន័យបឋម ឧទាហរណ៍ ខ្សែអក្សរ យើងអាចចូលប្រើវិធីសាស្ត្រ និងលក្ខណៈសម្បត្តិរបស់ពួកគេបាន ទោះបីជាមិនធ្វើការបំប្លែងជាក់លាក់ក៏ដោយ។ ចំណុចនៅទីនេះគឺថា នៅពេលព្យាយាមធ្វើប្រតិបត្តិការបែបនេះ ព្យញ្ជនៈត្រូវបានបំពាក់ដោយស្វ័យប្រវត្តិជាមួយនឹងឧបករណ៍រុំវត្ថុដែលសមស្រប។ នេះនាំឱ្យមានការពិតដែលថាលទ្ធផលនៃការគណនាកន្សោមមួយចំនួនគឺមិនត្រឹមត្រូវនព្វន្ធ។ អ្នកប្រហែលជាដឹងហើយថានៅក្នុង JS តម្លៃនៃកន្សោម 0.1 + 0.2 មិនស្មើនឹង 0.3 ទេ។ ក្នុងពេលជាមួយគ្នានេះនៅពេលធ្វើការជាមួយចំនួនគត់បញ្ហាបែបនេះមិនត្រូវបានគេសង្កេតឃើញទេនោះគឺ 1 + 2 === 3 ។

JavaScript មានវត្ថុលេខ ដែលជាវត្ថុរុំសម្រាប់តម្លៃលេខ។ វត្ថុនៃប្រភេទលេខអាចត្រូវបានបង្កើតដោយប្រើពាក្យបញ្ជាដូចជា var a = new Number(10) ឬអ្នកអាចពឹងផ្អែកលើឥរិយាបថស្វ័យប្រវត្តិនៃប្រព័ន្ធដែលបានពិពណ៌នាខាងលើ។ ជាពិសេស វាអនុញ្ញាតឱ្យវិធីសាស្ត្រដែលរក្សាទុកក្នុង Number.prototype ហៅនៅពេលអនុវត្តចំពោះព្យញ្ជនៈលេខ៖

(123).toString(); //"123" (1.23).toFixed(1); // "1.2"
មានមុខងារសកលដែលត្រូវបានរចនាឡើងដើម្បីបំប្លែងតម្លៃនៃប្រភេទផ្សេងទៀតទៅជាប្រភេទលេខ។ ទាំងនេះគឺជា parseInt() , parseFloat() និង Number() construct ដែលក្នុងករណីនេះដើរតួជាមុខងារធម្មតាដែលធ្វើការបំប្លែងប្រភេទ៖

ParseInt("1") //1 parseInt("អត្ថបទ") // NaN parseFloat("1.234") //1.234 លេខ("1") //1 លេខ("1.234") //1.234
ប្រសិនបើប្រតិបត្តិការដែលមានលេខនាំឱ្យអ្វីមួយដែលមិនមែនជាលេខ (កំឡុងពេលគណនាខ្លះ ឬនៅពេលព្យាយាមបំប្លែងអ្វីមួយទៅជាលេខ) JavaScript នឹងមិនបោះកំហុសទេ ប៉ុន្តែនឹងតំណាងឱ្យលទ្ធផលនៃប្រតិបត្តិការដូចជាតម្លៃ NaN ( មិនមែនលេខ មិនមែនលេខ)។ ដើម្បីពិនិត្យមើលថាតើតម្លៃគឺ NaN អ្នកអាចប្រើមុខងារ isNaN() ។

ប្រតិបត្តិការនព្វន្ធ JS ដំណើរការតាមរបៀបដែលធ្លាប់ស្គាល់ ប៉ុន្តែអ្នកត្រូវយកចិត្តទុកដាក់លើការពិតដែលថា ប្រតិបត្តិករ + អាចអនុវត្តទាំងការបន្ថែមលេខ និងការភ្ជាប់ខ្សែ។

1 + 1 //2 "1" + "1" //"11" 1 + "1" //"11"

▍Strings Strings ក្នុង JavaScript គឺជាលំដាប់នៃតួអក្សរយូនីកូដ។ ព្យញ្ជនៈ​ខ្សែអក្សរ​ត្រូវ​បាន​បង្កើត​ឡើង​ដោយ​ការ​ភ្ជាប់​អត្ថបទ​ដែល​ត្រូវ​មាន​ក្នុង​សម្រង់​ទ្វេ ("") ឬ​សម្រង់​តែមួយ ("")។ ដូចដែលបានបញ្ជាក់រួចមកហើយ នៅពេលធ្វើការជាមួយអក្សរអក្សរ យើងអាចពឹងផ្អែកលើការរុំវត្ថុដែលត្រូវគ្នា ដែលជាគំរូដើមដែលមានវិធីសាស្រ្តមានប្រយោជន៍ជាច្រើន រួមទាំងអក្សររង(), indexOf(), concat()។

"text".substring(1,3) //ex "text".indexOf("x") //2 "text".concat("end") //text end
ខ្សែអក្សរ ដូចជាតម្លៃបុព្វកាលផ្សេងទៀត គឺមិនអាចផ្លាស់ប្តូរបានទេ។ ឧទាហរណ៍ វិធីសាស្ត្រ concat() មិនកែប្រែខ្សែអក្សរដែលមានស្រាប់ទេ ប៉ុន្តែបង្កើតថ្មីមួយ។

▍តម្លៃប៊ូលីន ប្រភេទទិន្នន័យប៊ូលីនក្នុង JS ត្រូវបានតំណាងដោយតម្លៃពីរ - ពិត និងមិនពិត។ ភាសាអាចបំប្លែងតម្លៃផ្សេងៗដោយស្វ័យប្រវត្តិទៅជាប្រភេទទិន្នន័យប៊ូលីន។ ដូច្នេះ បន្ថែមពីលើតម្លៃឡូជីខលមិនពិត តម្លៃខាងក្រោមគឺទទេ មិនបានកំណត់ "" (ខ្សែអក្សរទទេ) 0 និង NaN ។ អ្វីៗផ្សេងទៀត រួមទាំងវត្ថុណាមួយ គឺជាតម្លៃពិត។ ក្នុងអំឡុងពេលប្រតិបត្តិការ Boolean អ្វីទាំងអស់ដែលត្រូវបានចាត់ទុកថាពិតត្រូវបានបំប្លែងទៅជាពិត ហើយអ្វីដែលចាត់ទុកថាមិនពិតត្រូវបានបំប្លែងទៅជាមិនពិត។ សូមក្រឡេកមើលឧទាហរណ៍ខាងក្រោម។ ដោយ​អនុលោម​តាម​គោលការណ៍​ខាង​លើ ខ្សែ​អក្សរ​ទទេ​នឹង​ត្រូវ​បាន​បំប្លែង​ទៅ​ជា​មិន​ពិត ហើយ​ជា​លទ្ធផល​នៃ​ការ​ប្រតិបត្តិ​កូដ​នេះ បន្ទាត់​នេះ​មិន​ពិត​នឹង​បង្ហាញ​ក្នុង​កុងសូល​។

អនុញ្ញាតឱ្យអត្ថបទ = ""; if(text)( console.log("នេះជាការពិត"); ) else ( console.log("This is false"); )

វត្ថុវត្ថុគឺជារចនាសម្ព័ន្ធថាមវន្តដែលបង្កើតឡើងដោយគូតម្លៃគន្លឹះ។ តម្លៃអាចជាប្រភេទទិន្នន័យបឋម វត្ថុ ឬមុខងារ។

វត្ថុត្រូវបានបង្កើតយ៉ាងងាយស្រួលបំផុតដោយប្រើវាក្យសម្ព័ន្ធព្យញ្ជនៈវត្ថុ៖

អនុញ្ញាតឱ្យ obj = (សារ: "សារ", doSomething: function() ())
លក្ខណៈសម្បត្តិរបស់វត្ថុអាចត្រូវបានអាន បន្ថែម កែសម្រួល និងលុបនៅពេលណាក៏បាន។ នេះជារបៀបដែលវាត្រូវបានធ្វើ៖

• ការអានលក្ខណៈសម្បត្តិ៖ object.name, object ។
• ការសរសេរទិន្នន័យទៅលក្ខណៈសម្បត្តិ (ប្រសិនបើទ្រព្យសម្បត្តិដែលកំពុងចូលប្រើមិនមានទេ ទ្រព្យសម្បត្តិថ្មីដែលមានសោដែលបានបញ្ជាក់ត្រូវបានបន្ថែម): object.name = តម្លៃ វត្ថុ = តម្លៃ។
• ការលុបលក្ខណៈសម្បត្តិ៖ លុប object.name លុប object ។

នេះគឺជាឧទាហរណ៍មួយចំនួន៖

អនុញ្ញាតឱ្យ obj = (); // ការបង្កើតវត្ថុទទេ obj.message = "សារ"; // adding a new property obj.message = "សារថ្មី"; // កែសម្រួលទ្រព្យសម្បត្តិលុប object.message; // ការលុបទ្រព្យសម្បត្តិ
វត្ថុនៅក្នុងភាសាត្រូវបានអនុវត្តជាតារាងសញ្ញា។ តារាង hash សាមញ្ញអាចត្រូវបានបង្កើតដោយប្រើពាក្យបញ្ជា Object.create(null)៖

អនុញ្ញាតឱ្យ បារាំង = Object.create(null); បារាំង["បាទ"] = "អ៊ូយ"; បារាំង["ទេ"] = "មិន"; ភាសាបារាំង["បាទ"];//"oui"
ប្រសិនបើអ្នកត្រូវការធ្វើឱ្យវត្ថុមិនអាចផ្លាស់ប្តូរបាន អ្នកអាចប្រើពាក្យបញ្ជា Object.freeze() ។

ដើម្បី​ធ្វើ​ឡើងវិញ​តាម​គ្រប់​លក្ខណសម្បត្តិ​របស់​វត្ថុ​មួយ អ្នក​អាច​ប្រើ​ពាក្យ​បញ្ជា Object.keys()៖

មុខងារ logProperty(name)( console.log(name); //property name console.log(obj); //property value ) Object.keys(obj).forEach(logProperty);

▍ ការប្រៀបធៀបតម្លៃនៃប្រភេទ និងវត្ថុបុព្វកាល នៅពេលធ្វើការជាក់ស្តែងជាមួយនឹងតម្លៃបុព្វកាល អ្នកអាចយល់ឃើញថាវាជាវត្ថុដែលមានលក្ខណៈសម្បត្តិ និងវិធីសាស្ត្រ ទោះបីជាវាមិនមែនជាវត្ថុក៏ដោយ។ តម្លៃបឋមគឺមិនអាចផ្លាស់ប្តូរបាន ហើយរចនាសម្ព័ន្ធខាងក្នុងរបស់វត្ថុអាចផ្លាស់ប្តូរ Variables នៅក្នុង JavaScript អថេរអាចត្រូវបានប្រកាសដោយប្រើពាក្យគន្លឹះ var, let, និង const ។

នៅពេលប្រើពាក្យគន្លឹះ var អ្នកអាចប្រកាសអថេរមួយ ហើយបើចាំបាច់ ចាប់ផ្តើមវាជាមួយនឹងតម្លៃជាក់លាក់មួយ។ ប្រសិនបើអថេរមិនត្រូវបានចាប់ផ្តើមទេ តម្លៃរបស់វាមិនត្រូវបានកំណត់ទេ។ អថេរដែលបានប្រកាសដោយប្រើពាក្យគន្លឹះ var មានវិសាលភាពមុខងារ។

ពាក្យគន្លឹះអនុញ្ញាតឱ្យគឺស្រដៀងទៅនឹង var ដែលភាពខុសគ្នានោះគឺថាអថេរដែលបានប្រកាសជាមួយពាក្យគន្លឹះអនុញ្ញាតឱ្យមានវិសាលភាពប្លុក។

អថេរ​ដែល​បាន​ប្រកាស​ដោយ​ប្រើ​ពាក្យ​គន្លឹះ const ក៏​មាន​វិសាលភាព​ប្លុក​ដែរ ដែល​ផ្ដល់​ឱ្យ​ថា​តម្លៃ​នៃ​អថេរ​បែប​នេះ​មិន​អាច​ផ្លាស់ប្ដូរ​បាន នោះ​នឹង​ត្រូវ​បាន​គេ​ហៅ​យ៉ាង​ត្រឹមត្រូវ​ជាង​ថា "ថេរ"។ ពាក្យគន្លឹះ const ដែលបង្កកតម្លៃនៃអថេរដែលបានប្រកាសដោយប្រើវាអាចប្រៀបធៀបទៅនឹង Object.freeze() method ដែលបង្កកវត្ថុ។

ប្រសិនបើអថេរត្រូវបានប្រកាសនៅខាងក្រៅមុខងារ នោះវិសាលភាពរបស់វាគឺសកល។

អារេ អារេ នៅក្នុង JavaScript ត្រូវបានអនុវត្តដោយប្រើវត្ថុ។ ជាលទ្ធផល នៅពេលដែលយើងនិយាយអំពីអារេ យើងកំពុងនិយាយអំពីវត្ថុដែលស្រដៀងនឹងអារេ។ អ្នកអាចធ្វើការជាមួយធាតុអារេដោយប្រើលិបិក្រមរបស់វា។ សន្ទស្សន៍ជាលេខត្រូវបានបំប្លែងទៅជាខ្សែអក្សរ ហើយប្រើជាឈ្មោះដើម្បីចូលប្រើតម្លៃធាតុអារេ។ ឧទាហរណ៍ construct ដូចជា arr គឺស្រដៀងនឹង construct ដូចជា arr["1"] ហើយទាំងពីរនឹងផ្តល់សិទ្ធិចូលប្រើតម្លៃដូចគ្នា៖ arr === arr["1"] ។ ដោយផ្អែកលើខាងលើ អារេសាមញ្ញដែលប្រកាសដោយ let arr = ["A", "B", "C"] ត្រូវបានតំណាងជាវត្ថុអ្វីមួយដូចនេះ៖

("0": "A", "1": "B", "2": "C")
ការដកធាតុចេញពីអារេដោយប្រើពាក្យបញ្ជាលុបទុករន្ធនៅក្នុងវា។ ដើម្បីជៀសវាងបញ្ហានេះ អ្នកអាចប្រើពាក្យបញ្ជា splice() ប៉ុន្តែវាមានភាពយឺតយ៉ាវ ពីព្រោះបន្ទាប់ពីដកធាតុមួយចេញ វាផ្លាស់ទីធាតុដែលនៅសល់នៃអារេ តាមការពិត ដោយប្តូរពួកវាទៅដើមអារេទៅខាងឆ្វេង។

អនុញ្ញាតឱ្យ arr = ["A", "B", "C"]; លុប arr; console.log(arr); // ["A", ទទេ, "C"] console.log(arr.length); // ៣
វិធីសាស្ត្រអារេ ធ្វើឱ្យមានភាពងាយស្រួលក្នុងការអនុវត្តរចនាសម្ព័ន្ធទិន្នន័យដូចជា ជង់ និងជួរ៖

// stack let stack = ; stack.push(1); // stack.push(2); // let last = stack.pop(); // console.log(ចុងក្រោយ); // 2 // ជួរ អនុញ្ញាតឱ្យជួរ = ; queue.push(1); // queue.push(2); // let first = queue.shift();// console.log(first); // ១

មុខងារ មុខងារនៅក្នុង JavaScript គឺជាវត្ថុ។ អនុគមន៍​អាច​ត្រូវ​បាន​កំណត់​ទៅ​អថេរ រក្សាទុក​ក្នុង​វត្ថុ ឬ​អារេ បញ្ជូន​ជា​អាគុយម៉ង់​ទៅ​អនុគមន៍​ផ្សេង​ទៀត ហើយ​ត្រឡប់​ពី​អនុគមន៍​ផ្សេង​ទៀត។

មានវិធីបីយ៉ាងដើម្បីប្រកាសមុខងារ៖

• ការ​ប្រកាស​មុខងារ​បុរាណ (Function Declaration or Function Statement)។
• ការ​ប្រើ​កន្សោម​អនុគមន៍ ដែល​ហៅ​ម្យ៉ាង​ទៀត​ថា Function Literals។
• ការប្រើវាក្យសម្ព័ន្ធមុខងារព្រួញ។

▍ការប្រកាសមុខងារបុរាណ ជាមួយនឹងវិធីសាស្រ្តនេះក្នុងការប្រកាសមុខងារ ច្បាប់ខាងក្រោមត្រូវបានអនុវត្ត៖

• ពាក្យគន្លឹះដំបូងនៅលើបន្ទាត់ប្រកាសមុខងារគឺមុខងារ។
• មុខងារត្រូវតែផ្តល់ឈ្មោះ។
• មុខងារមួយអាចត្រូវបានប្រើនៅក្នុងកូដមុនពេលការប្រកាសរបស់វាដោយសារតែយន្តការនៃការបង្កើនការប្រកាសមុខងារទៅកំពូលនៃវិសាលភាពដែលវាត្រូវបានប្រកាស។

នេះជាអ្វីដែលការប្រកាសមុខងារបុរាណមើលទៅដូច៖

មុខងារ doSomething()()

▍Function Expressions នៅពេលប្រើកន្សោមមុខងារ សូមពិចារណាដូចខាងក្រោម៖

• ពាក្យគន្លឹះមុខងារមិនមែនជាពាក្យដំបូងនៅលើបន្ទាត់ប្រកាសមុខងារទៀតទេ។
• ឈ្មោះមុខងារគឺស្រេចចិត្ត។ វា​អាច​ប្រើ​ទាំង​កន្សោម​មុខងារ​អនាមិក និង​ឈ្មោះ។
• ពាក្យបញ្ជាសម្រាប់ការហៅមុខងារបែបនេះត្រូវតែធ្វើតាមពាក្យបញ្ជាសម្រាប់ការប្រកាសពួកវា។
• មុខងារបែបនេះអាចត្រូវបានចាប់ផ្តើមភ្លាមៗបន្ទាប់ពីការប្រកាសរបស់វា ដោយប្រើវាក្យសម្ព័ន្ធ IIFE (Immediately Invoked Function Expression) ។

កន្សោមមុខងារមើលទៅដូចនេះ៖

អនុញ្ញាតឱ្យ doSomething = function()()

▍ មុខងារព្រួញ មុខងារព្រួញអាចចាត់ទុកថាជា "ជាតិស្ករសំយោគ" សម្រាប់បង្កើតកន្សោមមុខងារអនាមិក។ វាគួរតែត្រូវបានកត់សម្គាល់ថាមុខងារបែបនេះមិនមានអង្គភាពនេះនិងអាគុយម៉ង់ផ្ទាល់ខ្លួនទេ។ ការប្រកាសមុខងារព្រួញមើលទៅដូចនេះ៖

អនុញ្ញាតឱ្យធ្វើអ្វីមួយ = () = > ();

▍វិធីហៅមុខងារ មុខងារអាចត្រូវបានហៅតាមវិធីផ្សេងៗ ការហៅមុខងារធម្មតា doSomething(អាគុយម៉ង់) ការហៅមុខងារជាវិធីសាស្ត្រនៃវត្ថុ theObject.doSomething(arguments) theObject["doSomething"](អាគុយម៉ង់) ការហៅមុខងារជាអ្នកបង្កើត។ new doSomething(arguments) ការហៅមុខងារដោយប្រើវិធីសាស្រ្ត apply() doSomething.apply(theObject, ) doSomething.call(theObject, arguments) ការហៅមុខងារដោយប្រើវិធី bind() let doSomethingWithObject = doSomething.bind(theObject); doSomethingWithObject();
អនុគមន៍​អាច​ត្រូវ​បាន​ហៅ​ដោយ​មាន​អាគុយម៉ង់​ច្រើន​ឬ​តិច​ជាង​ចំនួន​ប៉ារ៉ាម៉ែត្រ​ដែល​ត្រូវ​បាន​បញ្ជាក់​នៅ​ពេល​ដែល​ពួកគេ​ត្រូវ​បាន​ប្រកាស។ ក្នុងអំឡុងពេលប្រតិបត្តិការមុខងារ អាគុយម៉ង់ "បន្ថែម" នឹងត្រូវបានមិនអើពើ (ទោះបីជាមុខងារនេះនឹងមានសិទ្ធិចូលប្រើពួកវាក៏ដោយ) ប៉ារ៉ាម៉ែត្រដែលបាត់នឹងទទួលបានតម្លៃដែលមិនបានកំណត់។

អនុគមន៍មានប៉ារ៉ាម៉ែត្រ pseudo-ពីរ: នេះ និងអាគុយម៉ង់។

▍ ពាក្យគន្លឹះនេះ ពាក្យគន្លឹះនេះតំណាងឱ្យបរិបទនៃមុខងារមួយ។ តម្លៃដែលវាចង្អុលបង្ហាញអាស្រ័យលើរបៀបដែលមុខងារត្រូវបានហៅ។ នេះគឺជាតម្លៃដែលពាក្យគន្លឹះនេះយក អាស្រ័យលើរបៀបដែលមុខងារត្រូវបានគេហៅថា (ពួកវាជាមួយឧទាហរណ៍កូដ សំណង់ដែលត្រូវបានប្រើនៅទីនេះ ត្រូវបានពិពណ៌នាខាងលើ)៖

• ការហៅមុខងារធម្មតាគឺបង្អួច / មិនបានកំណត់។
• ការហៅមុខងារជាវិធីសាស្រ្តនៃវត្ថុមួយ - theObject ។
• ការហៅមុខងារជា constructor គឺជាវត្ថុថ្មី។
• ការហៅមុខងារមួយដោយប្រើវិធីសាស្រ្ត apply() - theObject ។
• ការហៅមុខងារដោយប្រើវិធីសាស្ត្រ bind() - theObject ។

▍ ពាក្យគន្លឹះ អាគុយម៉ង់ ពាក្យគន្លឹះ អាគុយម៉ង់ គឺជាប៉ារ៉ាម៉ែត្រ pseudo ដែលផ្តល់សិទ្ធិចូលប្រើអាគុយម៉ង់ទាំងអស់ដែលប្រើក្នុងការហៅមុខងារ។ វាមើលទៅដូចជាអារេ ប៉ុន្តែវាមិនមែនជាអារេទេ។ ជាពិសេសវាមិនមានវិធីសាស្រ្តអារេទេ។

អនុគមន៍ reduceToSum(សរុប តម្លៃ)(ត្រឡប់សរុប + តម្លៃ; ) អនុគមន៍ sum())(អនុញ្ញាតឱ្យ args = Array.prototype.slice.call(arguments); ត្រឡប់ args.reduce(reduceToSum, 0); ) sum(1,2 , 3);
ជម្រើសជំនួសពាក្យគន្លឹះ អាគុយម៉ង់ គឺជាវាក្យសម្ព័ន្ធថ្មីសម្រាប់ប៉ារ៉ាម៉ែត្រដែលនៅសល់។ ក្នុងឧទាហរណ៍ខាងក្រោម args គឺជាអារេដែលមានអ្វីគ្រប់យ៉ាងដែលបានបញ្ជូនទៅអនុគមន៍នៅពេលវាត្រូវបានហៅ។

ផលបូកអនុគមន៍(...args)(ត្រឡប់ args.reduce(reduceToSum, 0); )

▍Return Statement អនុគមន៍​ដែល​មិន​មាន​សេចក្តី​ថ្លែង​ការណ៍​ត្រឡប់​នឹង​ត្រឡប់​មិន​បាន​កំណត់។ នៅពេលប្រើពាក្យគន្លឹះត្រឡប់ សូមយកចិត្តទុកដាក់លើរបៀបដែលយន្តការបញ្ចូលសញ្ញាក្បៀសស្វ័យប្រវត្តិដំណើរការ។ ឧទាហរណ៍ មុខងារខាងក្រោមនឹងមិនត្រឡប់វត្ថុទទេទេ ប៉ុន្តែតម្លៃដែលមិនបានកំណត់៖

អនុគមន៍ getObject() ( return ( ) ) getObject()
ដើម្បី​ជៀសវាង​បញ្ហា​នេះ សូម​ដាក់​ដង្កៀប​អង្កាញ់​បើក​លើ​បន្ទាត់​ដូចគ្នា​នឹង​សេចក្តី​ថ្លែងការណ៍​ត្រឡប់​វិញ៖

អនុគមន៍ getObject() (ត្រឡប់())

ការវាយបញ្ចូលថាមវន្ត JavaScript គឺជាភាសាដែលបានវាយបញ្ចូលថាមវន្ត។ នេះមានន័យថាតម្លៃបេតុងមានប្រភេទ ប៉ុន្តែអថេរមិនមាន។ កំឡុងពេលប្រតិបត្តិកម្មវិធី តម្លៃនៃប្រភេទផ្សេងៗគ្នាអាចត្រូវបានសរសេរទៅអថេរដូចគ្នា។ នេះគឺជាឧទាហរណ៍នៃមុខងារដែលធ្វើការជាមួយតម្លៃនៃប្រភេទផ្សេងៗគ្នា៖

កំណត់​ហេតុ​អនុគមន៍(តម្លៃ)( console.log(value); ) log(1); កំណត់ហេតុ ("អត្ថបទ"); កំណត់ហេតុ((សារ៖ "អត្ថបទ"));
ដើម្បីស្វែងយល់ពីប្រភេទទិន្នន័យដែលរក្សាទុកក្នុងអថេរ អ្នកអាចប្រើ typeof() operator៖

អនុញ្ញាតឱ្យ n = 1; ប្រភេទ(n); // លេខអនុញ្ញាតឱ្យ s = "អត្ថបទ"; ប្រភេទ(s); // ខ្សែអក្សរអនុញ្ញាតឱ្យ fn = មុខងារ () (); ប្រភេទ (fn); // មុខងារ

គំរូប្រតិបត្តិដែលមានខ្សែតែមួយ ពេលវេលាដំណើរការ JavaScript គឺខ្សែតែមួយ។ ជាពិសេស នេះត្រូវបានបញ្ជាក់នៅក្នុងភាពមិនអាចទៅរួចនៃការប្រតិបត្តិក្នុងពេលដំណាលគ្នានៃមុខងារពីរ (ប្រសិនបើអ្នកមិនគិតពីលទ្ធភាពនៃការប្រតិបត្តិកូដអសមកាលដែលយើងមិនប៉ះពាល់នៅទីនេះ)។ បរិយាកាសពេលដំណើរការមានអ្វីដែលហៅថា Event Queue ដែលរក្សាទុកបញ្ជីការងារដែលត្រូវដំណើរការ។ ជាលទ្ធផល គ្រោងការណ៍ប្រតិបត្តិ JS ខ្សែតែមួយមិនមានបញ្ហានៃការជាប់គាំងធនធានទេ ដូច្នេះមិនចាំបាច់មានយន្តការចាក់សោទេ។ ទោះយ៉ាងណាក៏ដោយ កូដដែលចូលទៅក្នុងជួរព្រឹត្តិការណ៍ត្រូវតែប្រតិបត្តិយ៉ាងរហ័ស។ ប្រសិនបើអ្នកផ្ទុកលើសទម្ងន់នៅក្នុងកម្មវិធីកម្មវិធីរុករកតាមអ៊ីនធឺណិតដែលមានការងារធ្ងន់ ទំព័រកម្មវិធីនឹងមិនឆ្លើយតបទៅនឹងការបញ្ចូលរបស់អ្នកប្រើប្រាស់ទេ ហើយកម្មវិធីរុករកនឹងប្រាប់អ្នកឱ្យបិទទំព័រនេះ ការគ្រប់គ្រងការលើកលែង JavaScript មានយន្តការសម្រាប់ដោះស្រាយករណីលើកលែង។ វាដំណើរការតាមគោលការណ៍ដែលធម្មតាសម្រាប់យន្តការបែបនេះ៖ កូដដែលអាចបណ្តាលឱ្យមានកំហុសត្រូវបានសរសេរដោយប្រើ try/catch construct ។ កូដខ្លួនវាស្ថិតនៅក្នុងប្លុកសាកល្បង កំហុសត្រូវបានដោះស្រាយនៅក្នុងប្លុកចាប់។

វាគួរឱ្យចាប់អារម្មណ៍ក្នុងការកត់សម្គាល់ថាជួនកាល JavaScript នៅពេលដែលស្ថានភាពអាសន្នកើតឡើងមិនបង្កើតសារកំហុសទេ។ នេះគឺដោយសារតែការពិតដែលថា JS មិនបានបោះកំហុសរហូតដល់ការអនុម័តស្តង់ដារ ECMAScript 3 ។

ឧទាហរណ៍ ក្នុង​អត្ថបទ​កូដ​ខាងក្រោម ការ​ព្យាយាម​កែប្រែ​វត្ថុ​ដែល​បង្កក​នឹង​បរាជ័យ ប៉ុន្តែ​គ្មាន​ការ​លើក​លែង​នឹង​ត្រូវ​បាន​បោះចោល​ទេ។

អនុញ្ញាតឱ្យ obj = Object.freeze(); obj.message = "អត្ថបទ";
មួយចំនួននៃ "ស្ងាត់" កំហុស JS លេចឡើងនៅក្នុងរបៀបតឹងរឹង, អ្នកអាចបើកវាដោយប្រើ "ប្រើយ៉ាងតឹងរឹង" ស្ថាបនា; .

ប្រព័ន្ធគំរូដើម ប្រព័ន្ធគំរូដើមក្រោមយន្តការ JS ដូចជាមុខងារ constructor ពាក្យបញ្ជា Object.create() និងពាក្យគន្លឹះថ្នាក់។
ពិចារណាឧទាហរណ៍ខាងក្រោម៖

អនុញ្ញាតឱ្យសេវាកម្ម = ( doSomething: function() () ) let specializedService = Object.create(service); console.log(specializedService.__proto__ === សេវាកម្ម); // ពិត
នៅទីនេះ ពាក្យបញ្ជា Object.create() ត្រូវបានប្រើដើម្បីបង្កើតវត្ថុសេវាកម្មឯកទេសដែលគំរូដើមត្រូវជាវត្ថុសេវាកម្ម។ ជាលទ្ធផល វាប្រែថាវិធីសាស្ត្រ doSomething() អាចត្រូវបានហៅដោយការចូលប្រើវត្ថុសេវាកម្មឯកទេស។ លើសពីនេះទៀត នេះមានន័យថា ទ្រព្យសម្បត្តិ __proto__ នៃវត្ថុសេវាកម្មឯកទេសចង្អុលទៅវត្ថុសេវាកម្ម។

ឥឡូវនេះ ចូរយើងបង្កើតវត្ថុស្រដៀងគ្នាដោយប្រើពាក្យគន្លឹះថ្នាក់៖

Class Service ( doSomething() ) class SpecializedService extends Service ( ) let specializedService = new SpecializedService(); console.log(specializedService.__proto__ === SpecializedService.prototype);
វិធីសាស្រ្តដែលបានប្រកាសនៅក្នុងថ្នាក់សេវាកម្មនឹងត្រូវបានបន្ថែមទៅវត្ថុ Service.prototype ។ ឧទាហរណ៍នៃថ្នាក់សេវាកម្មនឹងមានគំរូដូចគ្នា (Service.prototype) ។ វត្ថុទាំងអស់នឹងផ្ទេរការហៅតាមវិធីទៅវត្ថុ Service.prototype ។ ជាលទ្ធផល វាបង្ហាញថាវិធីសាស្រ្តត្រូវបានប្រកាសតែម្តងគត់នៅក្នុង Service.prototype បន្ទាប់ពីនោះពួកគេត្រូវបាន "ទទួលមរតក" ដោយគ្រប់ករណីនៃថ្នាក់។

▍ ខ្សែសង្វាក់គំរូវត្ថុអាចជា "អ្នកស្នង" នៃវត្ថុផ្សេងទៀត។ វត្ថុនីមួយៗមានគំរូដើមដែលវិធីសាស្ត្រមានសម្រាប់វា។ ប្រសិនបើអ្នកព្យាយាមចូលប្រើទ្រព្យសម្បត្តិដែលមិនមាននៅក្នុងវត្ថុខ្លួនឯង JavaScript នឹងចាប់ផ្តើមស្វែងរកវានៅក្នុងខ្សែសង្វាក់គំរូ។ ដំណើរការនេះនឹងបន្តរហូតដល់លក្ខណៈសម្បត្តិត្រូវបានរកឃើញ ឬរហូតដល់ការស្វែងរកឈានដល់ចុងបញ្ចប់នៃខ្សែសង្វាក់ អំពីមុខងារកម្មវិធីនៅក្នុង JavaScript នៅក្នុង JavaScript មុខងារគឺជាវត្ថុថ្នាក់ដំបូង ភាសាគាំទ្រយន្តការបិទ។ នេះបើកផ្លូវដើម្បីអនុវត្តបច្ចេកទេសសរសេរកម្មវិធីមុខងារនៅក្នុង JS ។ ជាពិសេសយើងកំពុងនិយាយអំពីលទ្ធភាពនៃការប្រើប្រាស់មុខងារលំដាប់ខ្ពស់ជាងនេះ។

ការបិទគឺជាមុខងារខាងក្នុងដែលមានសិទ្ធិចូលប្រើអថេរដែលបានប្រកាសនៅខាងក្នុងអនុគមន៍មេ សូម្បីតែបន្ទាប់ពីអនុគមន៍មេបានដំណើរការក៏ដោយ។

អនុគមន៍លំដាប់ខ្ពស់ គឺជាមុខងារដែលមានសមត្ថភាពយកមុខងារផ្សេងទៀតធ្វើជាអាគុយម៉ង់ មុខងារត្រឡប់ ឬធ្វើទាំងពីរ។

កម្មវិធីមុខងារនៅក្នុង JS ត្រូវបានគ្របដណ្តប់នៅក្នុងការបោះពុម្ពផ្សាយជាច្រើន។ ប្រសិនបើអ្នកចាប់អារម្មណ៍ នេះគឺជាសម្ភារៈមួយចំនួននៅលើប្រធានបទនេះឧទ្ទិសដល់

JavaScript ចូល​មក​ក្នុង​ការ​លេង​នៅ​ពេល​ដែល​យើង​ត្រូវ​ការ​ដើម្បី​អនុវត្ត​សកម្មភាព​មួយ​ចំនួន​នៅ​ខាង​អតិថិជន​ដែល​ចូល​ដំណើរ​ការ​គេហទំព័រ​របស់​យើង​។

JavaScript អាច​កែប្រែ​ទំព័រ​បណ្ដាញ​ដោយ​មិន​ចាំបាច់​ទាក់ទង​ម៉ាស៊ីន​បម្រើ ធ្វើ​ឱ្យ​មាន​សុពលភាព​តម្លៃ​នៃ​ការ​បញ្ចូល​របស់​អ្នក​ប្រើ និង​ធ្វើ​ប្រតិបត្តិការ​ផ្សេង​ទៀត។

អត្ថបទនេះផ្តល់នូវព័ត៌មានមូលដ្ឋានមួយចំនួន ដើម្បីឲ្យអ្នកចាប់ផ្តើមប្រើប្រាស់ JavaScript។

ការបញ្ចូលស្គ្រីបដោយផ្ទាល់ទៅក្នុងលេខកូដទំព័រ

អ្នកអាចបញ្ចូលកូដ JS ដោយផ្ទាល់នៅខាងក្នុងទំព័រ។

ដាស់តឿន ("សួស្តី!"); // កូដ JS មួយចំនួននៅទីនេះ

ផ្លាស់ទីកូដទៅក្នុងឯកសារដាច់ដោយឡែក

អ្នកអាចដាក់កូដ JavaScript ទៅក្នុងឯកសារខាងក្រៅ ហើយប្រើតំណភ្ជាប់ទៅវានៅលើទំព័រ

ស្លាកបិទគឺចាំបាច់ក្នុងករណីនេះ។

វាល្អបំផុតក្នុងការបញ្ចូលស្គ្រីបមុនស្លាកបិទ

Variables ឈ្មោះអថេរ

ឈ្មោះអថេរអាចចាប់ផ្តើមដោយអក្សរធំ អក្សរតូច សញ្ញាក្រោម ឬសញ្ញា $ ។

ឈ្មោះអាចមានលេខ ប៉ុន្តែឈ្មោះអថេរមិនអាចចាប់ផ្តើមដោយលេខបានទេ។

JavaScript គឺប្រកាន់អក្សរតូចធំ៖ mytext និង myText គឺជាអថេរពីរផ្សេងគ្នា។

វាជាការប្រសើរក្នុងការប្រើ CamelCase សម្រាប់ដាក់ឈ្មោះ ដោយចាប់ផ្តើមពាក្យនីមួយៗក្នុងឈ្មោះអថេរដោយអក្សរធំ។

ការប្រកាសអថេរ

Javascript ប្រើ var ដើម្បីប្រកាសអថេរ។

Var myText; //undefined myText = "សួស្តី!";

ការជូនដំណឹង (អត្ថបទរបស់ខ្ញុំ);

ភ្លាមៗបន្ទាប់ពីប្រកាសអថេរ តម្លៃរបស់វាមិនត្រូវបានកំណត់ទេ។

អ្នកអាចកំណត់តម្លៃទៅអថេរនៅពេលប្រកាសវា៖

Var myText = "សួស្តី!";

វាក៏អាចធ្វើទៅបានដើម្បីប្រកាសអថេរច្រើនក្នុង var មួយ៖

Var sum = 4 + 5, myText = "សួស្តី!";

នៅពេលកំណត់តម្លៃ var អាចត្រូវបានលុបចោលប៉ុន្តែវាប្រសើរជាងកុំធ្វើដូច្នេះ។

ប្រភេទអថេរ

នៅក្នុង JavaScript អ្នកអាចប្រើខ្សែអក្សរខាងក្រោម៖

Var myText = "ជំរាបសួរ!";

ចំនួនគត់៖

Var myNumber = 10;

លេខប្រភាគ៖

var pi = 3.14;

តម្លៃប៊ូលីន៖

Var isBoolean = មិនពិត;

សេចក្តីអធិប្បាយលម្អិតវាក្យសម្ព័ន្ធ JavaScript

មតិនៅលើបន្ទាត់ដូចគ្នាត្រូវបានបន្លិចដោយ "//" ។ អ្វីក៏ដោយបន្ទាប់ពីតួអក្សរទាំងនេះត្រូវបានចាត់ទុកថាជាមតិយោបល់។

ដើម្បីបញ្ចេញមតិច្រើនបន្ទាត់ សូមប្រើ "/*" ដើម្បីបង្ហាញពីការចាប់ផ្តើមនៃមតិយោបល់ និង "*/" ដើម្បីបង្ហាញពីចុងបញ្ចប់នៃមតិយោបល់។

/* នៅទីនេះត្រូវបាន commented code ហើយវាក៏ comment */

ការបំបែកប្រតិបត្តិករ

ដើម្បីបំបែកប្រតិបត្តិករអ្នកត្រូវប្រើ ";"

វាជាការគួរណែនាំ ប៉ុន្តែមិនចាំបាច់ប្រើចន្លោះពណ៌ស ដើម្បីបង្កើនការអាន។

ធ្វើការជាមួយខ្សែអក្សរ var str = 4 + 5 + "7"

នឹងផ្តល់តម្លៃខ្សែអក្សរ "97" នៅក្នុង str

Var str2 = "7" + 4 + 5

ការពិតគឺថាតម្លៃនៃការបន្ថែមត្រូវបានគណនាតាមលំដាប់លំដោយ - ពីឆ្វេងទៅស្តាំ។ នៅពេលដែលលេខ 2 ត្រូវបានបន្ថែម លទ្ធផលគឺជាលេខ។ នៅពេលដែលខ្សែអក្សរ និងលេខត្រូវបានបន្ថែម លេខត្រូវបានយល់ថាជាខ្សែអក្សរ ហើយខ្សែទាំងពីរត្រូវបានបញ្ចូលគ្នា។

ការបំប្លែងខ្សែអក្សរទៅជាលេខ

ដើម្បីបំប្លែងខ្សែអក្សរទៅជាលេខ សូមប្រើ parseInt() និង parseFloat()

មុខងារទាំងនេះទទួលបានអាគុយម៉ង់ពីរ។ ទីមួយ​គឺ​ខ្សែអក្សរ​ដែល​នឹង​ត្រូវ​បំប្លែង​ទៅជា​លេខ ហើយ​ទីពីរ​គឺ​ជា​មូលដ្ឋាន​ប្រព័ន្ធ​លេខ​ដែល​នឹង​ត្រូវ​ប្រើ​សម្រាប់​ការបកប្រែ។ ដើម្បីព្យាបាលខ្សែអក្សរជាលេខទសភាគ អ្នកត្រូវប្រើ 10 ជាអាគុយម៉ង់ទីពីរ

Var myNumber = parseInt("345", 10);

មុខងារ JavaScript

មុខងារនៅក្នុង JavaScript ត្រូវបានប្រកាសដូចនេះ៖

មុខងារ myFunction() (កូដ JS ខ្លះ)

ដើម្បីត្រឡប់តម្លៃ អ្នកត្រូវប្រើ ត្រឡប់៖

អនុគមន៍ myMultiplication(paramOne, paramTwo) (ត្រឡប់ paramOne * paramTwo)

អ្នកអាចប្រកាសមុខងារ "អនាមិក" ដោយលុបឈ្មោះសម្រាប់មុខងារ។

មុខងារមួយអាចត្រូវបានបញ្ជូនជាប៉ារ៉ាម៉ែត្រទៅមុខងារផ្សេងទៀតដោយបញ្ជាក់ឈ្មោះរបស់វា។

វត្ថុ

អ្វីគ្រប់យ៉ាងនៅក្នុង JavaScript គឺជាកូនចៅរបស់ Object ។

ការបង្កើតវត្ថុថ្មី var person = new Object(); //creating a person object person.firstname = "Andrew"; // add the first attribute person.lastname = "Peterson";// add the second attribute person.getFullName = function() (// add the method return this.firstname + " " + this.lastname; )

ទីពីរ ជម្រើសខ្លីសម្រាប់បង្កើតវត្ថុមួយ។

var person = ( // បង្កើត​ឈ្មោះ​វត្ថុ​បុគ្គល​៖ "អេនឌ្រូ​" នាមត្រកូល​៖ "ភីតធឺរសុន", getFullName: function() (ត្រឡប់ this.firstname + "" + this.lastname; ))

ធ្វើការជាមួយលក្ខណៈសម្បត្តិវត្ថុ

var me = new Object();

ខ្ញុំ["ឈ្មោះ"] = "ស៊ែរ";
me.age = 33;

Arrays ក្នុង JavaScript ការបង្កើត array var arr = new Array(11, "Hello!", true); // បង្កើតអារេ

វិធីថ្មីដើម្បីកត់ត្រា

វ៉ារ អារ = ; // បង្កើតអារេ

ធ្វើការជាមួយអារេក្នុង JavaScript ចំនួនធាតុក្នុងអារេ var length = arr.length; // 3 ការបន្ថែមធាតុទៅអារេ - រុញ arr.push("តម្លៃថ្មី"); ការទាញយកធាតុចុងក្រោយនៃអារេមួយ - pop var lastValue = arr.pop(); ការផ្សំអារេ var arr2 = ; var longArray = arr.concat(arr2); // រួមបញ្ចូលគ្នានូវអារេពីរ arr និង arr2 ទៅជា longArray Join - ការរួមបញ្ចូលគ្នានៃធាតុទាំងអស់នៃ array var longString = arr.join(":") // "11:Hello!:true" ការប្រៀបធៀប និងមុខងារឡូជីខលនៅក្នុង JavaScript ច្រើន ឬតិច var isTrue = 6 >= 5; // ធំជាង ឬស្មើសមភាព var isFalse = 1 == 2; // ស្មើនឹង isTrue = 1 != 2; // មិនស្មើគ្នា var alsoTrue = "6" == 6; Identity var notIdentical = "3" === 3 // false ព្រោះប្រភេទទិន្នន័យមិនត្រូវគ្នានឹង notIdentical = "3" !== 3 // true ព្រោះប្រភេទទិន្នន័យមិនត្រូវគ្នានឹង IF statement ប្រសិនបើ (5< 6) { alert("true!"); } else { alert("false!") } Оператор SWITCH var lunch = prompt("What do you want for lunch?","Type your lunch choice here"); switch(lunch){ case "sandwich": console.log("Sure thing! One sandwich, coming up."); break; case "soup": console.log("Got it! Tomato"s my favorite."); break; case "salad": console.log("Sounds good! How about a caesar salad?"); break; case "pie": console.log("Pie"s not a meal!"); break; default: console.log("Huh! I"m not sure what " + lunch + " is. How does a sandwich sound?"); } Логическое AND — && if (1 == 1 && 2 == 2) { alert("true!"); } Логическое OR — || if (1 == 1 || 2 == 3) { alert("true!"); } Логическое NOT — ! if (!(1 == 1)) { alert("false!"); } Циклы FOR for (var i = 0; i < 10; i = i + 1) { alert(i); } var names = [ "Sergey", "Andrey", "Petr" ]; for (var i = 0, len = names.length; i < len; i = i + 1) { alert(names[i]); } WHILE while (true) { // Бесконечный цикл alert("This will never stop!"); } var names = [ "Sergey", "Andrey", "Petr" ]; while (names.length >0) ( alert(names[i]); ) DO WHILE do ( alert("This will never stop!"); ) while (true) ( ​​// Infinite loop Lines text = "Blah blah blah blah blah blah blah Eric \ blah blah blah Eric blah blah Eric blah blah \ blah blah blah blah blah អេរិក"; អក្សរកាត់

ពេលខ្លះអ្នកមិនចង់បង្ហាញ ទាំងមូលខ្សែអក្សរ គ្រាន់តែជាផ្នែកមួយនៃវា។ ឧទាហរណ៍ នៅក្នុងប្រអប់សំបុត្រ Gmail របស់អ្នក អ្នកអាចកំណត់វាឱ្យបង្ហាញតួអក្សរ 50 ឬដូច្នេះដំបូងនៃសារនីមួយៗ ដូច្នេះអ្នកអាចមើលពួកវាជាមុនបាន។ ការមើលជាមុននេះគឺ ក ខ្សែអក្សររងនៃខ្សែអក្សរដើម (សារទាំងមូល) ។

"some word"។substring(x,y) ដែល x ជាកន្លែងដែលអ្នកចាប់ផ្តើមកាត់ ហើយ y គឺជាកន្លែងដែលអ្នកបញ្ចប់ការកាត់ខ្សែអក្សរដើម។

ផ្នែកលេខគឺចម្លែកបន្តិច។ ដើម្បីជ្រើសរើស "គាត់" នៅក្នុង "ជំរាបសួរ" អ្នកនឹងសរសេរនេះ: "ជំរាបសួរ" ។ ខ្សែអក្សររង (0, 2);

គិតថាមានសញ្ញាសម្គាល់នៅខាងឆ្វេងនៃតួអក្សរនីមួយៗដូចនេះ៖ 0-h-1-e-2-l-3-l-4-o-5 ។

ប្រសិនបើអ្នកកាត់នៅលេខ 0 ហើយម្តងទៀតនៅ 2 អ្នកនៅសល់តែគាត់។

ឧទាហរណ៍ច្រើនទៀត៖

1. 3 អក្សរដំបូងនៃ "Batman"
"Batman" ខ្សែអក្សររង(0,3)

2. ពីអក្សរទី 4 ដល់ទី 6 នៃ "កុំព្យូទ័រយួរដៃ"
"កុំព្យូទ័រយួរដៃ"។​ ខ្សែអក្សររង(3,6)

វាជាការល្អប្រសើរជាងមុនដើម្បីចាប់ផ្តើមរៀនមូលដ្ឋានគ្រឹះនៃការសរសេរកម្មវិធីជាមួយនឹងភាសាដែលអ្នកអាចស្វែងរកការងារបានយ៉ាងងាយស្រួល។ ជារៀងរាល់ឆ្នាំ សន្ទស្សន៍ TIOBE បោះពុម្ពផ្សាយចំណាត់ថ្នាក់នៃបច្ចេកវិទ្យាពេញនិយមបំផុត ក៏ដូចជាសក្ដានុពលនៃការកើនឡើង និងការធ្លាក់ចុះនៃប្រជាប្រិយភាពរបស់ពួកគេ។

ដោយផ្អែកលើទិន្នន័យទាំងនេះ អ្នកអាចតាមដានទីតាំងរបស់ Javascript និងទាញការសន្និដ្ឋានសមស្រប៖ ទោះបីជាភាសាមិនមែនជាការពេញនិយមបំផុតក៏ដោយ ក៏វាកំពុងអភិវឌ្ឍជាលំដាប់។ ដោយសារចំនួនកន្លែងទំនេរសម្រាប់មុខតំណែងអ្នកអភិវឌ្ឍន៍ផ្នែកខាងមុខកំពុងកើនឡើងជាលំដាប់ ហើយចំនួនផ្នែកដែល Javascript ត្រូវបានប្រើប្រាស់កំពុងកើនឡើង យើងសូមណែនាំឱ្យចាប់ផ្តើមជាមួយវា។

ប្រសិនបើអ្នកនៅតែមិនប្រាកដថាអ្នកអាចរៀន Javascript ពីដំបូងនោះ យើងនាំមកជូនអ្នកនូវអត្ថបទមួយដែលនឹងបង្ហាញភាពផ្ទុយគ្នាទាំងពាក្យ និងឧទាហរណ៍។

Javascript: រៀនពីដើម

ដំបូង​យើង​ប្រាប់​អ្នក​ពី​អ្វី​ទៅ​ជា Javascript ហើយ​ហេតុអ្វី​បាន​ជា​វា​ត្រូវ​ការ។

Javascript គឺជាបច្ចេកវិទ្យាដែលមានមូលដ្ឋានលើគំរូដើមដែលប្រើសម្រាប់សរសេរស្គ្រីបដែលត្រូវបានប្រតិបត្តិដោយកម្មវិធីពិសេស។

នៅពេលបកប្រែទៅជាភាសាមនុស្ស វាគឺជាតំណភ្ជាប់ជំនួយនៅក្នុងខ្សែសង្វាក់ដំណើរការកម្មវិធី-ស្គ្រីប។

ហេតុអ្វីចាំបាច់ Javascript? តើភាសាសរសេរកម្មវិធីនេះប្រើនៅឯណា? ប្រសិនបើអ្នកសម្រេចចិត្តបង្កើតកម្មវិធីទូរស័ព្ទ កុំព្យូទ័រលើតុ និងឆ្លងវេទិកា ហ្គេម អតិថិជន និងផ្នែកម៉ាស៊ីនមេនៃកម្មវិធីគេហទំព័រ នោះអ្នកត្រូវបានស្វាគមន៍ក្នុងការប្រើប្រាស់ Javascript ។ នេះពិតជាបច្ចេកវិទ្យាពហុមុខងារដែលស័ក្តិសមសម្រាប់ការអភិវឌ្ឍន៍មនុស្សជាច្រើន ប្រសិនបើមិនមែនអ្វីៗទាំងអស់។

ដោយវិធីនេះ! សម្រាប់អ្នកអានរបស់យើងឥឡូវនេះមានការបញ្ចុះតម្លៃ 10% នៅលើ

មូលដ្ឋានគ្រឹះ Javascript សម្រាប់អ្នកចាប់ផ្តើមដំបូង៖ កន្លែងដែលត្រូវរៀន

តើធ្វើដូចម្តេចដើម្បីរៀន JavaScript ពីដំបូង? របៀបរៀនសរសេរកម្មវិធីដោយខ្លួនឯង? អ្នកសរសេរកម្មវិធីចាប់ផ្តើមជាច្រើនសួរសំណួរទាំងនេះ។ ជាសំណាងល្អ ចម្លើយមាន ហើយវាលម្អិតណាស់។

មានជម្រើសជាច្រើនសម្រាប់ការរៀនភាសាសរសេរកម្មវិធីនេះ៖

• វគ្គសិក្សាឯកទេស,
• ការសិក្សាឯករាជ្យ
• សិក្សានៅសាកលវិទ្យាល័យ។

ជាមួយនឹងវគ្គសិក្សាឯកទេសអ្វីគ្រប់យ៉ាងគឺច្បាស់លាស់: មករៀន។ គ្រូបង្រៀននៅក្នុងវគ្គសិក្សាបែបនេះកំពុងអនុវត្តអ្នកអភិវឌ្ឍន៍ដែលមិនត្រឹមតែចែករំលែកប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងពង្រឹងចំណុចទ្រឹស្តីជាមួយនឹងការអនុវត្តផងដែរ។

វគ្គសិក្សាត្រូវតែមានរយៈពេលយូរ។ ក្នុងមួយខែៗ គ្មាននរណាម្នាក់អាចបង្រៀនអ្នកបានទេ!

របៀបរៀន Javascript ដោយខ្លួនឯង៖ 4 វិធី

ប្រសិនបើអ្នកចង់រៀន JavaScript ដោយខ្លួនឯង អ្នកនឹងត្រូវមានវិន័យខ្លួនឯងខ្លាំងបំផុត និងខិតខំប្រឹងប្រែងដើម្បីធ្វើឱ្យវាដំណើរការ។ ដូចដែលពួកគេនិយាយ ការអត់ធ្មត់ និងការងារនឹងបំផ្លាញអ្វីៗទាំងអស់។

មុនពេលអ្នកចាប់ផ្តើមសរសេរកម្មវិធីនៅក្នុង Javascript អ្នកត្រូវគិតតាមរយៈផែនការរៀបចំរបស់អ្នកឱ្យបានលម្អិត។ យើងផ្តល់ជូននូវកំណែរបស់យើង ហើយអ្នកអាចកែសម្រួលវាអាស្រ័យលើគោលដៅ សមត្ថភាព និងសមត្ថភាពរបស់អ្នក។

1. រៀនរៀននិងចងចាំរឿងសាមញ្ញ។ សមត្ថភាពសម្រាប់ការអភិវឌ្ឍន៍ខ្លួនឯងត្រូវអភិវឌ្ឍ។ វាមានសារៈសំខាន់ខ្លាំងណាស់ក្នុងការរៀនប្រកបដោយផ្លែផ្កា។ វាទាមទារការលត់ដំខ្លួន និងគោលដៅដ៏រឹងមាំ ដូច្នេះមុនពេលអ្នកចាប់ផ្តើមរៀន ចូរបង្រៀនខ្លួនឯងពីរបៀបរៀន។

2. រៀនមូលដ្ឋានគ្រឹះនៃ JavaScript ។ Codecademy៖ រៀន JavaScript, SnoopCode: JavaScript Tutorials, មគ្គុទ្ទេសក៍ JavaScript របស់ MDN - ធនធានអនឡាញទាំងនេះគ្របដណ្តប់វេយ្យាករណ៍ ប្រភេទ រង្វិលជុំ មុខងារ កន្សោម លេខ កាលបរិច្ឆេទ ការធ្វើទ្រង់ទ្រាយ និងច្រើនទៀត។

3. ចាប់ផ្តើមរុករកមុខងារភាសាកម្រិតខ្ពស់។ បន្ទាប់​ពី​អ្នក​បាន​រៀន​ពី​មូលដ្ឋាន​ហើយ សូម​ចាប់​ផ្ដើម​ធ្វើ​ជាម្ចាស់​បណ្ណាល័យ និង​ក្របខ័ណ្ឌ៖ JQuery, ReactJS, Angular 2, node.jsដែលនឹងអនុញ្ញាតឱ្យមានការអភិវឌ្ឍន៍លើផ្នែក server និងផ្សេងទៀត។

4. បង្កើតគម្រោងផ្ទាល់ខ្លួនរបស់អ្នក។ Free Code Camp គឺជាសហគមន៍អ្នកអភិវឌ្ឍន៍ ដែលអ្នកអាចបង្ហោះកូដ បង្កើតគម្រោង និងទទួលបានវិញ្ញាបនបត្រសម្រាប់វា។ ហើយ​រឿង​សំខាន់​គឺ​ត្រូវ​ទទួល​មតិ​ត្រឡប់​ពី​សមាជិក​សហគមន៍​ផ្សេង​ទៀត។

ការអភិវឌ្ឍន៍វិជ្ជាជីវៈ៖ ការអនុវត្ត និងការអនុវត្តបន្ថែមទៀត

អ្នក​អាច​សិក្សា​អក្សរសិល្ប៍​បាន​មួយ​តោន ប៉ុន្តែ​បើ​គ្មាន​ការ​អនុវត្ត​ជាប់​លាប់​ទេ អ្នក​នឹង​មិន​សម្រេច​អ្វី​បាន​ឡើយ។

មនុស្សម្នាក់មិនអាចត្រូវបានគេហៅថាជាម្ចាស់នៃសិប្បកម្មរបស់គាត់បានទេប្រសិនបើគាត់ដឹងអ្វីៗទាំងអស់ប៉ុន្តែមិនអាចធ្វើអ្វីបានទេ។

ការសរសេរកម្មវិធី ដូចជាអាជីវកម្មផ្សេងទៀត ទាមទារការអនុវត្តជាប្រចាំ។ កាន់តែប្រសើរ រៀននិងអនុវត្តក្នុងពេលតែមួយ។ វិធីនេះអ្នកនឹងសាកល្បងទ្រឹស្ដីភ្លាមៗក្នុងការអនុវត្ត ហើយយល់ពីកន្លែងដែលអ្នកកំពុងធ្វើខុស។ ហើយនឹងមានកំហុសជឿខ្ញុំ។ ប៉ុន្តែកុំខ្លាចវា។ ផ្ទុយ​ទៅ​វិញ បើ​គ្មាន​កំហុស​នឹង​មិន​មាន​ការ​រីក​ចម្រើន​ឡើយ។

រៀបចំផែនការថ្ងៃរបស់អ្នកដើម្បីឱ្យអ្នកមានពេលសិក្សាពីរម៉ោងជារៀងរាល់ថ្ងៃ។ កុំធ្វើការខ្លាំងពេក។ សម្រាក និងផ្លាស់ប្តូរសកម្មភាពរបស់អ្នក។ ល្អណាស់សម្រាប់ការរៀន Javascript ។

មើលមេរៀនវីដេអូ អាន និងរក្សាទុកអត្ថបទគួរឱ្យចាប់អារម្មណ៍ ចូលរួមសិក្ខាសាលា និងសន្និសីទ ពិភាក្សា និងចែករំលែកគំនិតរបស់អ្នកជាមួយសិស្សផ្សេងទៀត។

ជាទូទៅ អ្នកមានការងារច្រើន ប៉ុន្តែអ្នកប្រហែលជាមិនមានពេលគ្រប់គ្រាន់ទេ ប្រសិនបើអ្នកកំពុងសិក្សានៅសាកលវិទ្យាល័យផងដែរ។ ដូច្នេះ យើងស្នើឱ្យអ្នកទាក់ទងសេវាសិស្ស ដើម្បីធ្វើឱ្យជីវិតរបស់អ្នកកាន់តែងាយស្រួល និងសម្រេចបាននូវគោលដៅរបស់អ្នក។