តើអ្វីជាភាពខុសគ្នារវាង printIn និង console.log នៅក្នុង JavaScript? (ចម្លើយ) - ភាពខុសគ្នាទាំងអស់។

04-06-202304-06-2023 Mary Davis

តារាងមាតិកា

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

“PrintIn” ធ្វើឱ្យអត្ថបទត្រូវបានបោះពុម្ពទៅកុងសូល ចំណែកឯអ្នក អាចប្រើ “console.log” ដើម្បីកត់ត្រាវា ហើយប្រើវាសម្រាប់គោលបំណងផ្សេងៗ ដូចជាការផ្ញើអ៊ីមែលវាជារបាយការណ៍បញ្ហា។

ប្រសិនបើអ្នកជាអ្នកសរសេរកម្មវិធី អ្នកដឹងពីសារៈសំខាន់នៃការប្រើប្រាស់ និងយល់ ភាសាស្គ្រីបដូចជា JavaScript គឺ។ ទោះយ៉ាងណាក៏ដោយ មានពេលខ្លះដែលអ្នកអាចច្រឡំអំពីមុខងាររបស់វា។

ដូចមុខងារ printIn និង console.log ដែរ។ ដើម្បីជួយអ្នកឱ្យយល់ពីភាពខុសគ្នា និងការអនុវត្តមុខងារទាំងពីរនេះ ខ្ញុំនឹងពន្យល់ពីអត្ថន័យរបស់វា និងរបៀបដែលពួកវាដំណើរការ។

តោះចាប់ផ្តើម!

តើ JavaScript ជាអ្វី?

តើ JavaScript គឺជាអ្វី?

JavaScript គឺជាភាសាស្គ្រីបសម្រាប់បង្កើតសម្ភារៈដែលបានធ្វើបច្ចុប្បន្នភាពជាប្រចាំ ការគ្រប់គ្រងពហុមេឌៀ ក្រាហ្វិកមានចលនា និងអ្វីៗជាច្រើនទៀត។

ភាសាសរសេរកម្មវិធី JavaScript មានសមត្ថភាពសរសេរកម្មវិធីស្តង់ដារមួយចំនួនដែលអាចឱ្យអ្នកធ្វើអ្វីៗដូចជា៖

នៅពេលដែលព្រឹត្តិការណ៍ជាក់លាក់កើតឡើងនៅលើទំព័របណ្តាញ អ្នកអាចឆ្លើយតបទៅនឹងកូដដែលកំពុងដំណើរការ។
អ្នកអាចប្រើអថេរដើម្បីរក្សាទុកទិន្នន័យមានប្រយោជន៍។
អ្នកអាចប្រើ "ខ្សែអក្សរ" ដែលជាប្រតិបត្តិការកែសម្រួលអត្ថបទនៅក្នុងការសរសេរកម្មវិធី

មុខងារដែលបានបន្ថែមនៅផ្នែកខាងលើនៃភាសា JavaScript របស់អ្នកប្រើប្រាស់គឺកាន់តែគួរឱ្យចាប់អារម្មណ៍។ ចំណុចប្រទាក់កម្មវិធីកម្មវិធី (APIs) ផ្តល់មុខងារបន្ថែមកូដ JavaScript របស់អ្នក។

និយាយឱ្យខ្លី JavaScript មានមុខងារជាច្រើនដែលអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងអ្វីដែលអ្នកកំពុងសរសេរកូដ។ មុខងារទាំងនេះរួមមាន printIn និង console.log។

តើអ្វីជា PrintIn?

ការសរសេរកូដ

PrintIn គឺជាវិធីសាស្ត្រ Java សម្រាប់បង្ហាញអត្ថបទនៅលើកុងសូល។ វិធីសាស្ត្រនេះទទួលយកអត្ថបទនេះជាប៉ារ៉ាម៉ែត្រក្នុងទម្រង់ជា String។ វិធីសាស្រ្តនេះបោះពុម្ពអត្ថបទទៅកុងសូល ខណៈពេលដែលរក្សាទស្សន៍ទ្រនិចនៅដើមបន្ទាត់ខាងក្រោម។

ការបោះពុម្ពបន្ទាប់ ចាប់ផ្តើមនៅបន្ទាត់បន្ទាប់ ។ មានវិធីសាស្រ្ត printIn ជាច្រើនដូចជា៖

void printIn()	សរសេរខ្សែបន្ទាត់បំបែកបន្ទាត់ដើម្បីបញ្ចប់បន្ទាត់បច្ចុប្បន្ន។
void printIn(boolean x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីការបោះពុម្ពប៊ូលីន។
void printIn(char x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីបោះពុម្ពតួអក្សរ។
void print(char [ ] x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីបោះពុម្ពអារេនៃតួអក្សរ។ បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីការបោះពុម្ពបន្ទាត់ទ្វេ។
void printIn(float x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីការបោះពុម្ព។<17
ទុកជាមោឃៈprintIn(int x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីបោះពុម្ពចំនួនគត់។
void printIn(long x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីបោះពុម្ព។
void printIn(Object x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីបោះពុម្ពវត្ថុមួយ។
ទុកជាមោឃៈ printIn(String x)	បន្ទាត់ត្រូវបានបញ្ចប់បន្ទាប់ពីការបោះពុម្ពខ្សែអក្សរ។

ការប្រើប្រាស់វិធីសាស្រ្តផ្សេងគ្នានៅក្នុង printIn

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

ដើម្បីកុំឱ្យអ្នកមានការភ័ន្តច្រឡំរវាងវិធីសាស្រ្តនៃការបោះពុម្ពទាំងពីរនេះ តោះ កំណត់ភាពខុសគ្នារវាងវិធីសាស្ត្រទីពីរក្នុងការបោះពុម្ព ការបោះពុម្ព។

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

ការបោះពុម្ពបន្ទាប់ នឹងចាប់ផ្តើមនៅទីនេះ ។ មានវិធីបោះពុម្ពជាច្រើនដូចជា៖

void print(boolean b)	តម្លៃប៊ូលីនត្រូវបានបោះពុម្ព។
ការបោះពុម្ពជាមោឃៈ(តួអក្សរ គ)	តួអក្សរមួយត្រូវបានបោះពុម្ព។
ការបោះពុម្ពជាមោឃៈ(តួអក្សរ [ ] s)	អារេនៃតួអក្សរមួយត្រូវបានបោះពុម្ព។ លេខចំណុចអណ្តែតត្រូវបានបោះពុម្ព។
ការបោះពុម្ពចាត់ទុកជាមោឃៈ (float f)	លេខចំណុចអណ្តែតត្រូវបានបោះពុម្ព។
ការបោះពុម្ពចាត់ទុកជាមោឃៈ(int i)	ចំនួនគត់ត្រូវបានបោះពុម្ព។
ការបោះពុម្ពគ្មានការបោះពុម្ព(បណ្តោយ )	ចំនួនគត់វែងត្រូវបានបោះពុម្ព។
ការបោះពុម្ពទុកជាមោឃៈ(វត្ថុវត្ថុ)	វត្ថុមួយត្រូវបានបោះពុម្ព .
ការបោះពុម្ពទុកជាមោឃៈ(ខ្សែអក្សរ s)	ខ្សែអក្សរមួយត្រូវបានបោះពុម្ព។

ការប្រើប្រាស់វិធីផ្សេងគ្នាក្នុងការបោះពុម្ព

និយាយឱ្យខ្លី ភាពខុសគ្នាសំខាន់រវាងទាំងពីរគឺការដាក់អត្ថបទដែលបានបោះពុម្ពនៅក្នុងកុងសូល។ PrintIn គឺនៅដើមបន្ទាត់ខាងក្រោម ខណៈពេលដែល Print ស្ថិតនៅ ចុងបញ្ចប់នៃបន្ទាត់ខាងក្រោម។

ប្រសិនបើអ្នកចាប់អារម្មណ៍ចង់ដឹងអំពី windows 10-pro និង pro-n សូមពិនិត្យមើល ចេញពីអត្ថបទផ្សេងទៀតរបស់ខ្ញុំ។

តើ Console.log ជាអ្វី?

Console.log

កុងសូលគឺជាវត្ថុ JavaScript ដែលផ្តល់ឱ្យអ្នកនូវការចូលទៅកាន់កុងសូលបំបាត់កំហុសរបស់កម្មវិធីរុករក។

សូមមើលផងដែរ: ផ្ទុកខ្សែទល់នឹងខ្សែបន្ទាត់ (ការប្រៀបធៀប) – ភាពខុសគ្នាទាំងអស់។

console.log គឺជា JavaScript មុខងារដែលបោះពុម្ពអថេរណាមួយដែលត្រូវបានកំណត់ពីមុននៅក្នុងវា ក៏ដូចជាព័ត៌មានទាំងឡាយណាដែលចាំបាច់ត្រូវបង្ហាញដល់អ្នកប្រើប្រាស់។

ទិន្នផលភាគច្រើនត្រូវបានកត់ត្រា (បោះពុម្ព) ទៅកាន់ស្ថានីយ។ ប្រភេទណាមួយអាចត្រូវបានបញ្ជូនទៅ log() រួមទាំងខ្សែអក្សរ អារេ វត្ថុ និងប៊ូលីន។

វិធីសាស្ត្ររបស់ console.log()លទ្ធផលអាចមើលឃើញនៅក្នុងកុងសូល JavaScript ដែលអាចចូលប្រើបានតាមរយៈឧបករណ៍អ្នកអភិវឌ្ឍន៍របស់កម្មវិធីរុករកតាមអ៊ីនធឺណិត។ អ្វីក៏ដោយដែលអ្នកបញ្ចេញជាមួយ console.log() គឺអាចចូលប្រើបានសម្រាប់អ្នកប្រើប្រាស់ចុងក្រោយទាំងអស់ ដោយមិនគិតពីក្រុម ឬតួនាទីរបស់ពួកគេ។

តោះមើលពីរបៀបដែលអ្នកអាចប្រើវា និងលទ្ធផលបន្ទាប់ពីប្រើមុខងារនេះ។

សូមមើលផងដែរ: ភាពខុសគ្នារវាង Stacks, Racks និង Bands- (ពាក្យត្រឹមត្រូវ) - All The Differences

JavaScript លទ្ធផល

// console. log() method

console.log('abc');

console.log(1);

console .log(true);

console .log(null);

console .log(undefined);

console .log([1, 2, 3, 4]); // array inside lo g

console .log({a:1, b:2, c:3}); // object inside lo g

abc

ពិត

null

មិនបានកំណត់

អារេ(4) [ 1, 2, 3, 4 ]

វត្ថុ { a : 1, b : 2 , c : 3

ការបញ្ចូល និងលទ្ធផលដោយប្រើ console.log

តើអ្វីជា Print to Console ជាមួយ Console.log method ក្នុង Javascript?

វាគឺជាវិធីសាស្ត្រកុងសូលដ៏ពេញនិយម និងប្រើប្រាស់យ៉ាងទូលំទូលាយរបស់ JavaScript។ វិធីសាស្រ្តនេះត្រូវបានប្រើជាញឹកញាប់ដើម្បីបោះពុម្ពសារផ្សេងៗ ឬលទ្ធផលគណនាទៅកាន់កុងសូល ឬសូម្បីតែពេលកំពុងកែកូដ។

អ្នកបានសរសេរកូដមួយចំនួនដែលបន្ថែមលេខពីរ ហើយអ្នកចង់ឃើញលទ្ធផល នៃប្រតិបត្តិការនោះនៅលើកុងសូល; ក្នុងករណីនេះ អ្នកអាចប្រើវិធីសាស្ត្រ console.log()។

តើ Console.log synchronous ឬ asynchronous?

មុននឹងខ្ញុំពិភាក្សាជាមួយអ្នកថាតើ console.log គឺ synchronous ឬ asynchronous ខ្ញុំនឹងកំណត់ជាមុនថា synchronous និង asynchronous ជាអ្វី។

Synchronous មានន័យថាវាកើតឡើងក្នុងពេលតែមួយ ចំណែក asynchronous មានន័យថា វាមិនកើតឡើងក្នុងពេលតែមួយទេ។ ដូច្នេះអ្នកចូលរួម/អ្នកប្រើប្រាស់នៅក្នុងសមកាលកម្មអាចទទួលបានមតិកែលម្អភ្លាមៗ។ Asynchronous អនុញ្ញាតឱ្យអ្នករៀនតាមពេលវេលារបស់អ្នក។

ដើម្បីឆ្លើយ concole.log គឺអសមកាល។ ខ្ញុំនឹងបង្ហាញអ្នកពីមូលហេតុនោះ តាមរយៈការបង្ហាញឧទាហរណ៍ ជាពិសេសការតម្រៀបអារេនៃវត្ថុក្នុងលក្ខណៈកាន់តែមានប្រសិទ្ធភាព។ តោះចាប់ផ្តើម។

ឧបមាថាអ្នកមានវត្ថុខាងក្រោមនៅក្នុងអារេរបស់អ្នក៖

អនុញ្ញាតឱ្យអ្នកប្រើប្រាស់ = [ { name: “Nicole” , age: 20, នាមត្រកូល៖ “លូណា” } , { ឈ្មោះ៖ “ការ៉ា” អាយុ៖ ២១ ឆ្នាំ នាមត្រកូល៖ “លីម” }, { ឈ្មោះ៖ “ឡារ៉ា” អាយុ៖ ២០ ឆ្នាំ នាមត្រកូល៖ “ទូហ្សូន” }; ]

វត្ថុអារេ

អ្នកត្រូវតែតម្រៀបអារេនេះតាមឈ្មោះវាល ដែលជាធម្មតាត្រូវបានធ្វើដូចខាងក្រោម។

/ / តាមឈ្មោះ ( Cara, Lara, Nicole )

users.sort ( ( a, b ) => a.name > b.name ? 1 : -1);

/ / តាមអាយុ ( Lara, Nicole, Cara )

users.sort ( ( a, b ) => a.age > b.name ? 1 : -1);

ការតម្រៀបវត្ថុអារេ

ដើម្បីរៀបចំវាឱ្យកាន់តែមានប្រសិទ្ធភាព អ្នកនឹងមានដូចនេះ៖

users.sort(byField( 'name' ));

users.sort(byField( 'age' ));

ការតម្រៀបវត្ថុអារេ (វិធីសាមញ្ញ)

ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវតែសរសេរអនុគមន៍ "Byfield" ដើម្បីឆ្លងកាត់ ហើយតម្រៀបវាទៅ Array.prototype.sort នៃវត្ថុនៅក្នុងអារេរបស់អ្នក។ ជាការប្រសើរណាស់ នេះមិនមែនជាការផ្តោតសំខាន់នៃអត្ថបទនេះទេ ប៉ុន្តែសូមមើលឧទាហរណ៍ខាងក្រោម ដើម្បីបំពេញឧទាហរណ៍ខាងលើតាមរបៀបសាមញ្ញ។

> អនុញ្ញាតឱ្យអ្នកប្រើប្រាស់ =[ { ឈ្មោះ៖ “នីកូល”, អាយុ៖ ២០, នាមត្រកូល៖ “លូណា” }, { ឈ្មោះ៖ “ខារ៉ា”, អាយុ៖ ២១, នាមត្រកូល៖ “លីម”}, { ឈ្មោះ៖ “ឡារ៉ា”, អាយុ៖ ២០, នាមត្រកូល៖ “ទូហ្សុន” }; ]

function byField (fieldName){ return (a, b) => a [fieldName] ? ១:-១; }

users.sort(byField( 'name' ) );

concole.log(users);

users.sort(byField( 'age' ) );

concole.log(users);

(3) [ { … }, { … }, { … } ]

> 0: { ឈ្មោះ៖ ” Lara “, អាយុ៖ ” 20”, នាមត្រកូល៖ ” Tuazon” }

> 1: { ឈ្មោះ៖ ” Nicole “, អាយុ៖ ” 20”, នាមត្រកូល៖ ” Luna ” }

> 1: { ឈ្មោះ៖ ” Cara “, អាយុ៖ ” 21”, នាមត្រកូល៖ ” Lim”

ប្រវែង៖ 3

> _proto_៖ អារេ (0)

(3) [ { … }, { … }, { … } ]

> 0: { ឈ្មោះ៖ ” Lara “, អាយុ៖ ” 20”, នាមត្រកូល៖ ” Tuazon” }

> 1: { ឈ្មោះ៖ ” Nicole “, អាយុ៖ ” 20”, នាមត្រកូល៖ ” Luna ” }

> 1: { ឈ្មោះ៖ ” Cara “, អាយុ៖ ” 21”, នាមត្រកូល៖ ” Lim”

ប្រវែង៖ 3

> _proto_៖ អារេ (0)

វត្ថុអារេដែលបានតម្រៀប

អ្នកអាចមើលឃើញពីតារាងខាងលើដែលខ្ញុំតម្រៀប វត្ថុអារេពីរដង ខ្ញុំតម្រៀបតាមឈ្មោះដំបូង បន្ទាប់តាមអាយុ ហើយបន្ទាប់ពីប្រតិបត្តិការតម្រៀបនីមួយៗ ខ្ញុំដំណើរការ console.log () ។ ដូចគ្នានេះផងដែរ អ្នកប្រហែលជាបានសង្កេតឃើញថា console.log() បានស្ដារលទ្ធផលដូចគ្នាសម្រាប់រាល់ប្រភេទនៃលទ្ធផល ប៉ុន្តែនេះមិនមែនជាករណីនោះទេ។ អនុញ្ញាតឱ្យខ្ញុំពន្យល់ពីមូលហេតុ។

ខ្ញុំបានដំណើរការកូដខាងលើទាំងអស់ក្នុងពេលតែមួយ បន្ទាប់មកសម្រេចចិត្តពង្រីករាល់ប្រតិកម្មពី console.log ()។ នេះគឺសំខាន់ព្រោះ console.log() គឺasynchronous។

នៅក្នុងលក្ខខណ្ឌនៃ Event Loop លក្ខណៈពិសេសអសមកាលទាំងអស់មកដល់តារាងព្រឹត្តិការណ៍។ ក្នុងករណីនេះ បន្ទាប់ពីបង្ហាញ console.log() វាដំណើរការទៅតារាងព្រឹត្តិការណ៍ ហើយរង់ចាំព្រឹត្តិការណ៍ជាក់លាក់ណាមួយកើតឡើង។

នៅពេលដែលព្រឹត្តិការណ៍កើតឡើង console.log() នឹងត្រូវបានផ្ញើទៅកាន់ Event Queue ដែលវារង់ចាំរហូតដល់ដំណើរការទាំងអស់នៅក្នុង Event Queue ដែលមានវត្តមានរួចហើយ នៅពេលដែល console.log របស់អ្នកត្រូវបានដាក់ និងត្រូវបានផ្ញើទៅកាន់ Call Stack បន្ទាប់មក console.log() របស់អ្នកក៏កំពុងត្រូវបានផ្ញើទៅកាន់ Call Stack ផងដែរ។

របៀបបើក Javascript Console.log?

នៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិត កុងសូលគឺជាផ្នែកមួយនៃឧបករណ៍អ្នកអភិវឌ្ឍន៍ជាច្រើន។ ដើម្បីដោះស្រាយបញ្ហាកូដ JavaScript របស់អ្នក អ្នកអាចប្រើ Console ។ កុងសូលអាចរកបាននៅកន្លែងជាច្រើនអាស្រ័យលើកម្មវិធីរុករក។

ខ្ញុំនឹងបង្រៀនអ្នកពីកន្លែងដែលត្រូវស្វែងរកកុងសូលនៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិត Google Chrome របស់អ្នកនៅក្នុងការបង្រៀននេះ។

ជំហានអំពីរបៀបបើកកុងសូលនៅក្នុង Chrome

តោះមើលពីរបៀបបើកកំណត់ហេតុកុងសូល Chrome។

ជ្រើសរើស ពិនិត្យ ពីម៉ឺនុយលេចឡើង ខណៈពេលដែលកម្មវិធីរុករក Chrome បើក។

ឧបករណ៍អ្នកអភិវឌ្ឍន៍ "ធាតុ" ផ្ទាំងនឹងត្រូវបានបើកតាមលំនាំដើម នៅពេលអ្នកដំណើរការ ពិនិត្យ។ នៅខាងស្តាំនៃ "ធាតុ" ចុច "កុងសូល" ឧបករណ៍អ្នកអភិវឌ្ឍន៍ Chrome ដោយប្រើគ្រាប់ចុចផ្លូវកាត់មួយចំនួន។ យោងតាមកំណែរបស់ Chrome របស់អ្នក។អាចប្រើផ្លូវកាត់ខាងក្រោម៖

សម្រាប់ Windows និង Linux,

Ctrl + Shift + I	បង្អួចឧបករណ៍អ្នកអភិវឌ្ឍន៍នឹងលេចឡើង។
Ctrl + Shift + J	ជ្រើសរើសផ្ទាំង Console ក្នុងឧបករណ៍អ្នកអភិវឌ្ឍន៍។
Ctrl + Shift + C	ពិនិត្យមើលការបិទ/បើករបៀបធាតុ

គ្រាប់ចុចផ្លូវកាត់

ការគិតចុងក្រោយ

ភាពខុសគ្នាចម្បង រវាង printIn និង console.log គឺជាមុខងាររបស់ពួកគេ និង លទ្ធផលនៃកូដ ។ PrintIn បោះពុម្ពអត្ថបទទៅកុងសូល ខណៈពេលដែល console.log បោះពុម្ពអថេរណាមួយជាមួយនឹងខ្សែអក្សរដែលត្រូវបានសរសេរកូដពីមុន។

ជាមូលដ្ឋាន មុខងារទាំងនេះរបស់ Javascript អនុញ្ញាតឱ្យអ្នកបោះពុម្ព និងបង្ហាញអថេរ និងអត្ថបទទៅកាន់កុងសូល។ នៅក្នុង JavaScript អ្នកអាចបោះពុម្ពដោយប្រើវិធីសាស្ត្រផ្សេងៗ។

វិធីសាស្ត្រកំណត់កុងសូល JavaScript គឺជាជម្រើសដែលប្រើញឹកញាប់បំផុតនៅពេលធ្វើការកែកំហុស។ ដើម្បីបំបាត់កំហុសកូដរបស់អ្នកឱ្យកាន់តែមានប្រសិទ្ធភាព អ្នកគួរតែអនុវត្តពួកវាទាំងអស់ ហើយរៀនពីរបៀបប្រើពួកវាឱ្យបានត្រឹមត្រូវ។

អ្នកសរសេរកម្មវិធី និងអ្នកអភិវឌ្ឍន៍តែងតែប្រើវាដើម្បីបោះពុម្ពអថេរណាមួយដែលត្រូវបានកំណត់ជាមុននៅក្នុងវា ក៏ដូចជាព័ត៌មានដែលត្រូវការ ត្រូវបានបង្ហាញដល់អ្នកប្រើប្រាស់។