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

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

ចូរសង្ខេបអត្ថប្រយោជន៍របស់ AJAX៖

• សមត្ថភាពក្នុងការបង្កើតចំណុចប្រទាក់គេហទំព័រងាយស្រួល
• អន្តរកម្មអ្នកប្រើប្រាស់សកម្ម
• ភាពងាយស្រួលនៃការប្រើប្រាស់

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

ដើម្បីផ្លាស់ប្តូរទិន្នន័យ វត្ថុ XMLHttpRequest ត្រូវតែត្រូវបានបង្កើតនៅលើទំព័រ ដែលជាប្រភេទនៃអន្តរការីរវាងកម្មវិធីរុករករបស់អ្នកប្រើប្រាស់ និងម៉ាស៊ីនមេ (រូបភាពទី 1)។ ដោយប្រើ XMLHttpRequest អ្នកអាចផ្ញើសំណើទៅម៉ាស៊ីនមេ ហើយក៏ទទួលបានការឆ្លើយតបក្នុងទម្រង់ផងដែរ។ ប្រភេទផ្សេងៗទិន្នន័យ។

មានវិធីពីរយ៉ាងក្នុងការផ្លាស់ប្តូរទិន្នន័យជាមួយម៉ាស៊ីនមេ។ វិធីសាស្រ្តដំបូងគឺការស្នើសុំ GET ។ នៅក្នុងសំណើនេះ អ្នកចូលប្រើឯកសារនៅលើម៉ាស៊ីនមេ ដោយឆ្លងកាត់អាគុយម៉ង់របស់វាតាមរយៈ URL ខ្លួនឯង។ ក្នុងករណីនេះ នៅខាងអតិថិជន វានឹងសមហេតុផលក្នុងការប្រើមុខងារគេចចេញពី Javascript ដូច្នេះទិន្នន័យមួយចំនួនមិនរំខានសំណើរ។

ផ្នែកម៉ាស៊ីនភ្ញៀវ ដែលសរសេរជា Javascript ត្រូវតែផ្តល់មុខងារចាំបាច់សម្រាប់ការផ្លាស់ប្តូរសុវត្ថិភាពជាមួយម៉ាស៊ីនមេ និងផ្តល់វិធីសាស្រ្តសម្រាប់ការផ្លាស់ប្តូរទិន្នន័យតាមវិធីណាមួយខាងលើ។ ផ្នែកម៉ាស៊ីនមេត្រូវតែដំណើរការទិន្នន័យបញ្ចូល ហើយផ្អែកលើវា បង្កើតព័ត៌មានថ្មី (ឧទាហរណ៍ ធ្វើការជាមួយមូលដ្ឋានទិន្នន័យ) ហើយផ្ញើវាត្រឡប់ទៅម៉ាស៊ីនភ្ញៀវវិញ។ ឧទាហរណ៍ ដើម្បីស្នើសុំព័ត៌មានពីម៉ាស៊ីនមេ អ្នកអាចប្រើសំណើ GET ធម្មតាជាមួយនឹងការផ្ទេរប៉ារ៉ាម៉ែត្រតូចៗជាច្រើន ប៉ុន្តែដើម្បីធ្វើបច្ចុប្បន្នភាពព័ត៌មាន ឬបន្ថែមព័ត៌មានថ្មី អ្នកនឹងត្រូវប្រើសំណើ POST ព្រោះវាអនុញ្ញាតឱ្យអ្នកផ្ទេរទំហំធំ។ បរិមាណទិន្នន័យ។

ដូចដែលបានបញ្ជាក់រួចមកហើយ AJAX ប្រើការផ្ទេរទិន្នន័យអសមកាល។ នេះមានន័យថាខណៈពេលដែលទិន្នន័យកំពុងត្រូវបានផ្ទេរ អ្នកប្រើប្រាស់អាចធ្វើសកម្មភាពចាំបាច់ផ្សេងទៀត។ នៅពេលនេះ អ្នកប្រើប្រាស់គួរតែត្រូវបានជូនដំណឹងថា ការផ្លាស់ប្តូរទិន្នន័យមួយចំនួនកំពុងកើតឡើង បើមិនដូច្នេះទេ អ្នកប្រើប្រាស់នឹងគិតថាមានអ្វីខុសបានកើតឡើង ហើយអាចនឹងចាកចេញពីគេហទំព័រ ឬហៅមុខងារដែលគាត់គិតថា "ជាប់គាំង" ឡើងវិញ។ ការចង្អុលបង្ហាញក្នុងអំឡុងពេលទំនាក់ទំនងនៅក្នុងកម្មវិធី Web 2.0 ដើរតួនាទីយ៉ាងសំខាន់៖ អ្នកទស្សនាប្រហែលជាមិនទាន់ស៊ាំនឹងវិធីនៃការធ្វើបច្ចុប្បន្នភាពទំព័រនេះទេ។

ការឆ្លើយតបពីម៉ាស៊ីនមេអាចមិនត្រឹមតែ XML ដូចដែលឈ្មោះនៃបច្ចេកវិទ្យាបានបង្ហាញនោះទេ។ បន្ថែមពីលើ XML អ្នកអាចទទួលបានការឆ្លើយតបក្នុងទម្រង់ អត្ថបទ​ធម្មតាឬ JSON (Javascript Object Notation)។ ប្រសិនបើការឆ្លើយតបត្រូវបានទទួល នៅក្នុងអត្ថបទធម្មតា។បន្ទាប់មកវាអាចត្រូវបានបង្ហាញភ្លាមៗនៅក្នុងធុងមួយនៅលើទំព័រ។ នៅពេលទទួលបានការឆ្លើយតបជាទម្រង់ XML ឯកសារ XML ដែលទទួលបានជាធម្មតាត្រូវបានដំណើរការនៅផ្នែកអតិថិជន ហើយទិន្នន័យត្រូវបានបំប្លែងទៅជា (X)HTML ។ នៅពេលទទួលបានការឆ្លើយតបជាទម្រង់ JSON អតិថិជនគ្រាន់តែត្រូវការប្រតិបត្តិកូដដែលបានទទួល (មុខងារ eval របស់ Javascript) ដើម្បីទទួលបានវត្ថុ Javascript ពេញលេញ។ ប៉ុន្តែនៅទីនេះ អ្នកត្រូវប្រុងប្រយ័ត្ន និងគិតគូរពីការពិតដែលថា កូដព្យាបាទអាចត្រូវបានបញ្ជូនដោយប្រើបច្ចេកវិទ្យានេះ ដូច្នេះមុនពេលប្រតិបត្តិកូដដែលទទួលបានពីម៉ាស៊ីនមេ អ្នកគួរតែពិនិត្យ និងដំណើរការវាដោយប្រុងប្រយ័ត្ន។ មានការអនុវត្តដូចជាសំណើ "ទំនេរ" ដែលមិនមានការឆ្លើយតបពីម៉ាស៊ីនមេទេ មានតែទិន្នន័យនៅលើផ្នែកម៉ាស៊ីនមេប៉ុណ្ណោះដែលត្រូវបានផ្លាស់ប្តូរ។

នៅក្នុងកម្មវិធីរុករកផ្សេងៗគ្នា វត្ថុនេះមាន លក្ខណៈសម្បត្តិផ្សេងគ្នាប៉ុន្តែជាទូទៅវាត្រូវគ្នា។

XMLHttp ស្នើសុំវិធីសាស្រ្តវត្ថុ

ចំណាំថាឈ្មោះវិធីសាស្រ្តត្រូវបានសរសេរក្នុងរចនាប័ទ្ម Camel ដូចគ្នានឹងមុខងារ Javascript ផ្សេងទៀត។ ប្រយ័ត្នពេលប្រើពួកវា។

រំលូតកូន()- លុបចោលសំណើបច្ចុប្បន្នទៅកាន់ម៉ាស៊ីនមេ។

getAllResponseHeaders()- ទទួលបានបឋមកថាឆ្លើយតបទាំងអស់ពីម៉ាស៊ីនមេ។

getResponseHeader("header_name")- ទទួលបានបឋមកថាដែលបានបញ្ជាក់។

បើក ("request_type", "URL", "អសមកាល", "ឈ្មោះអ្នកប្រើប្រាស់", "ពាក្យសម្ងាត់")- ចាប់ផ្តើមសំណើទៅកាន់ម៉ាស៊ីនមេ ដោយបញ្ជាក់វិធីសាស្ត្រស្នើសុំ។ ប្រភេទសំណើ និង URL គឺជាប៉ារ៉ាម៉ែត្រដែលត្រូវការ។ អាគុយម៉ង់ទីបីគឺជាតម្លៃប៊ូលីន។ ជាធម្មតា ពិតតែងតែត្រូវបានបញ្ជាក់ ឬមិនបានបញ្ជាក់ទាល់តែសោះ (លំនាំដើមគឺពិត)។ អាគុយម៉ង់ទី 4 និងទី 5 ត្រូវបានប្រើសម្រាប់ការផ្ទៀងផ្ទាត់ (វាមិនមានសុវត្ថិភាពខ្លាំងណាស់ក្នុងការរក្សាទុកទិន្នន័យការផ្ទៀងផ្ទាត់នៅក្នុងស្គ្រីប ចាប់តាំងពីស្គ្រីបអាចត្រូវបានមើលដោយអ្នកប្រើប្រាស់ណាមួយ) ។

ផ្ញើ ("មាតិកា")- ផ្ញើសំណើ HTTP ទៅម៉ាស៊ីនមេ ហើយទទួលការឆ្លើយតប។

setRequestHeader("header_name", "value")- កំណត់តម្លៃបឋមកថាសំណើ។

លក្ខណសម្បត្តិរបស់វត្ថុ XMLHttpRequest

onreadystatechange- មួយនៃលក្ខណៈសម្បត្តិសំខាន់បំផុតនៃវត្ថុ XMLHttpRequest ។ ដោយប្រើលក្ខណសម្បត្តិនេះ អ្នកដោះស្រាយត្រូវបានបញ្ជាក់ដែលត្រូវបានគេហៅថានៅពេលណាដែលស្ថានភាពនៃវត្ថុផ្លាស់ប្តូរ។

រដ្ឋរួចរាល់- លេខបង្ហាញពីស្ថានភាពរបស់វត្ថុ។

អត្ថបទឆ្លើយតប- តំណាងនៃការឆ្លើយតបរបស់ម៉ាស៊ីនមេជាអត្ថបទធម្មតា (ខ្សែអក្សរ) ។

ការឆ្លើយតបXML- វត្ថុឯកសារដែលត្រូវគ្នានឹង DOM បានទទួលពីម៉ាស៊ីនមេ។

ស្ថានភាព- ស្ថានភាពនៃការឆ្លើយតបពីម៉ាស៊ីនមេ។

អត្ថបទស្ថានភាព- តំណាងអត្ថបទនៃស្ថានភាពឆ្លើយតបពីម៉ាស៊ីនមេ។

អ្នកគួរតែពិនិត្យមើលឱ្យបានដិតដល់នូវទ្រព្យសម្បត្តិរដ្ឋដែលត្រៀមរួចជាស្រេច៖

• 0 - វត្ថុមិនត្រូវបានចាប់ផ្តើមទេ។
• 1 - វត្ថុកំពុងផ្ទុកទិន្នន័យ។
• 2 - វត្ថុបានផ្ទុកទិន្នន័យរបស់វា។
• 3 - វត្ថុមិនត្រូវបានផ្ទុកពេញលេញទេ ប៉ុន្តែអាចត្រូវបានអន្តរកម្មដោយអ្នកប្រើប្រាស់។
• 4 - វត្ថុត្រូវបានចាប់ផ្តើមយ៉ាងពេញលេញ; ការឆ្លើយតបត្រូវបានទទួលពីម៉ាស៊ីនមេ។

វាផ្អែកលើស្ថានភាពត្រៀមខ្លួនរបស់វត្ថុដែលអ្នកអាចផ្តល់ឱ្យអ្នកទស្សនានូវព័ត៌មានអំពីដំណាក់កាលនៃដំណើរការផ្លាស់ប្តូរទិន្នន័យជាមួយម៉ាស៊ីនមេ ហើយអាចជូនដំណឹងដល់គាត់អំពីរូបភាពដែលមើលឃើញ។ ការបង្កើតវត្ថុ XMLHttpRequest

ដូចដែលបានរៀបរាប់ខាងលើការបង្កើតវត្ថុនេះសម្រាប់ប្រភេទនៃកម្មវិធីរុករកនីមួយៗគឺជាដំណើរការតែមួយគត់។

ឧទាហរណ៍ ដើម្បីបង្កើតវត្ថុមួយនៅក្នុងកម្មវិធីរុករកដែលឆបគ្នាជាមួយ Gecko Konqueror និង Safari អ្នកត្រូវប្រើកន្សោមខាងក្រោម៖

Var Request = new XMLHttpRequest();

ហើយសម្រាប់ Internet Explorer ខាងក្រោមត្រូវបានប្រើ៖

Var Request = new ActiveXObject("Microsoft.XMLHTTP");

Var Request = new ActiveXObject("Msxml2.XMLHTTP");

ឥឡូវនេះ ដើម្បីសម្រេចបាននូវភាពឆបគ្នារបស់កម្មវិធីរុករកតាមអ៊ីនធឺណិត អ្នកត្រូវបញ្ចូលគ្នានូវមុខងារទាំងអស់ទៅជាតែមួយ៖

មុខងារ CreateRequest() ( var Request = false; if (window.XMLHttpRequest) ( // Gecko-compatible browsers, Safari, Konqueror Request = new XMLHttpRequest(); ) else if (window.ActiveXObject) ( // Internet explorer try ( Request = new ActiveXObject("Microsoft.XMLHTTP"); ) catch (CatchException) ( Request = new ActiveXObject("Msxml2.XMLHTTP"); ) ) ប្រសិនបើ (!Request) ( alert("Cannot create XMLHttpRequest"); ) return Request; )

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

ស្នើសុំទៅម៉ាស៊ីនមេ

ក្បួនដោះស្រាយសំណើរបស់ម៉ាស៊ីនមេមើលទៅដូចនេះ៖

• កំពុងពិនិត្យមើលអត្ថិភាពនៃ XMLHttpRequest ។
• ចាប់ផ្តើមការតភ្ជាប់ទៅម៉ាស៊ីនមេ។
• ផ្ញើសំណើទៅម៉ាស៊ីនមេ។
• ដំណើរការទិន្នន័យដែលទទួលបាន។

ដើម្បីបង្កើតសំណើទៅកាន់ម៉ាស៊ីនមេ យើងនឹងបង្កើតមុខងារតូចមួយដែលនឹងបញ្ចូលគ្នាក្នុងមុខងារ មុខងារសម្រាប់សំណើ GET និង POST ។

/* មុខងារសម្រាប់ផ្ញើសំណើទៅកាន់ឯកសារនៅលើម៉ាស៊ីនមេ r_method - ប្រភេទសំណើ៖ GET ឬ POST r_path - ផ្លូវទៅកាន់ឯកសារ r_args - អាគុយម៉ង់ដូចជា a=1&b=2&c=3... r_handler - មុខងារដែលគ្រប់គ្រងការឆ្លើយតបពី server */ function SendRequest(r_method, r_path, r_args, r_handler) ( // បង្កើតសំណើរ var Request = CreateRequest(); // ពិនិត្យអត្ថិភាពនៃសំណើម្តងទៀត ប្រសិនបើ (!Request) ( return ; ) // Assign a custom handler Request.onreadystatechange = function() ( // ប្រសិនបើការផ្លាស់ប្តូរទិន្នន័យត្រូវបានបញ្ចប់ ប្រសិនបើ (Request.readyState == 4) ( // ឆ្លងកាត់ការគ្រប់គ្រងទៅកាន់ user handler r_handler(Request); )) // ពិនិត្យមើលថាតើវាចាំបាច់ដើម្បី ធ្វើការស្នើសុំ GET ប្រសិនបើ (r_method.toLowerCase() == "get" && r_args.length > 0) r_path += "?" + r_args; // ចាប់ផ្តើមការតភ្ជាប់ Request.open(r_method, r_path, true); ប្រសិនបើ ( r_method.toLowerCase() == "ប្រកាស") ( // ប្រសិនបើនេះជាសំណើ POST // កំណត់បឋមកថា Request.setRequestHeader("Content-Type","application/x-www-form-urlencoded; charset=utf- 8"); // ផ្ញើសំណើ Request.send(r_args); ) else ( // ប្រសិនបើនេះជាសំណើរទទួលបាន // ផ្ញើសំណើរសុំជាមោឃៈ Request.send(null); ) )

ការបង្កើតសំណើបានកាន់តែងាយស្រួល។ ឧទាហរណ៍ ចូរយើងសរសេរមុខងារមួយដែលនឹងទទួលបានមាតិកានៃឯកសារនៅលើម៉ាស៊ីនមេ ហើយបញ្ជូនវាទៅកុងតឺន័រ។

មុខងារ ReadFile(ឈ្មោះឯកសារ កុងតឺន័រ) ( // បង្កើតមុខងារដោះស្រាយ var Handler = function(Request) ( document.getElementById(container).innerHTML = Request.responseText; ) // ផ្ញើសំណើ SendRequest("GET",filename," ", អ្នកដោះស្រាយ);)

នេះជារបៀបដែលអន្តរកម្មជាមួយម៉ាស៊ីនមេកើតឡើង។

កំពុងដំណើរការការឆ្លើយតប

ក្នុងឧទាហរណ៍មុន យើងបានធ្វើមុខងារស្នើសុំទៅម៉ាស៊ីនមេ។ ប៉ុន្តែ​វា​មិន​មាន​សុវត្ថិភាព​ទេ ព្រោះ​យើង​មិន​ដំណើរការ​ស្ថានភាព​របស់​វត្ថុ និង​ស្ថានភាព​នៃ​ការ​ឆ្លើយតប​ពី​ម៉ាស៊ីន​មេ។

ចូរបន្ថែមទៅកូដរបស់យើងដើម្បីឱ្យវាអាចបង្ហាញការជូនដំណឹងដែលមើលឃើញអំពីដំណើរការផ្ទុក។

Request.onreadystatechange = function() ( // ប្រសិនបើការផ្លាស់ប្តូរទិន្នន័យត្រូវបានបញ្ចប់ ប្រសិនបើ (Request.readyState == 4) ( // ឆ្លងកាត់ការគ្រប់គ្រងទៅកាន់អ្នកប្រើប្រាស់ r_handler(Request); ) else ( // ជូនដំណឹងដល់អ្នកប្រើប្រាស់អំពីការទាញយក ))...

ដូចដែលអ្នកបានដឹងរួចមកហើយ វត្ថុ XMLHttpRequest អនុញ្ញាតឱ្យអ្នកដឹងពីស្ថានភាពនៃការឆ្លើយតបពីម៉ាស៊ីនមេ។ ចូរយើងទាញយកប្រយោជន៍ពីឱកាសនេះ។

Request.onreadystatechange = function() ( // ប្រសិនបើការផ្លាស់ប្តូរទិន្នន័យត្រូវបានបញ្ចប់ ប្រសិនបើ (Request.readyState == 4) (ប្រសិនបើ (Request.status == 200) ( // ឆ្លងកាត់ការគ្រប់គ្រងទៅអ្នកគ្រប់គ្រងអ្នកប្រើប្រាស់ r_handler(Request); ) ផ្សេងទៀត ( // យើងជូនដំណឹងដល់អ្នកប្រើប្រាស់អំពីកំហុសដែលបានកើតឡើង) ) ផ្សេងទៀត ( // ជូនដំណឹងដល់អ្នកប្រើប្រាស់អំពីការទាញយក ) ) ...

ជម្រើសឆ្លើយតបរបស់ម៉ាស៊ីនមេ

អ្នកអាចទទួលបានប្រភេទទិន្នន័យជាច្រើនពីម៉ាស៊ីនមេ៖

• អត្ថបទ​ធម្មតា

ប្រសិនបើអ្នកទទួលបានអត្ថបទធម្មតា អ្នកអាចផ្ញើវាភ្លាមៗទៅកាន់កុងតឺន័រ ពោលគឺទៅកាន់លទ្ធផល។ នៅពេលទទួលទិន្នន័យជា XML អ្នកត្រូវតែដំណើរការទិន្នន័យដោយប្រើមុខងារ DOM ហើយបង្ហាញលទ្ធផលដោយប្រើ HTML ។

JSONគឺជាការសម្គាល់វត្ថុ Javascript ។ ដោយមានជំនួយរបស់វា អ្នកអាចតំណាងឱ្យវត្ថុមួយជាខ្សែអក្សរ (នៅទីនេះអ្នកអាចផ្តល់ភាពស្រដៀងគ្នាជាមួយមុខងារសៀរៀល)។ នៅពេលអ្នកទទួលបានទិន្នន័យ JSON អ្នកត្រូវតែប្រតិបត្តិវាដើម្បីទទួលបានវត្ថុ Javascript ពេញលេញ និងអនុវត្តប្រតិបត្តិការចាំបាច់នៅលើវា។ សូម​ដឹង​ថា ការ​បញ្ជូន​ទិន្នន័យ និង​ការ​ប្រតិបត្តិ​បែប​នេះ​មិន​មាន​សុវត្ថិភាព​ទេ។ អ្នកត្រូវតែតាមដាននូវអ្វីដែលចូលមកសម្រាប់ការប្រតិបត្តិ។

កូដ JSON គំរូ៖
( "data": ( "misc": [ ( "name" : "JSON element one", "type" : "subheading 1"), ( "name" : "JSON element two", "type" : " ចំណងជើងរង 2 ")]))

នៅពេលទទួលបានកូដបែបនេះ សូមអនុវត្តសកម្មភាពខាងក្រោម៖

Var responsedata = eval("("+Request.responseText +")")

បន្ទាប់ពីប្រតិបត្តិកូដនេះ វត្ថុនឹងមានសម្រាប់អ្នក ទិន្នន័យឆ្លើយតប.

ធ្វើការជាមួយភាសាសរសេរកម្មវិធីចំហៀងម៉ាស៊ីនមេ

ការងារ​បែប​នេះ​មិន​ខុស​ពី​ការងារ​ធម្មតា​ទេ។ ឧទាហរណ៍ ខ្ញុំនឹងយក PHP ជាភាសាខាងម៉ាស៊ីនមេ។ គ្មាន​អ្វី​បាន​ផ្លាស់​ប្តូ​រ​នៅ​ខាង​ម៉ាស៊ីន​ភ្ញៀវ ប៉ុន្តែ​ខាង​ម៉ាស៊ីន​បម្រើ​ត្រូវ​បាន​តំណាង​ដោយ​ឯកសារ PHP ។

តាមប្រពៃណី ចូរចាប់ផ្តើមជាមួយនឹងការស្វាគមន៍ទៅកាន់ពិភពលោកដ៏អស្ចារ្យរបស់យើង៖

បន្ទរ "ជំរាបសួរពិភពលោក!";

នៅពេលចូលប្រើឯកសារនេះ ខ្សែអក្សរ Hello, World នឹងត្រូវប្រគល់ជូនអតិថិជនវិញ។ ដូចដែលអ្នកអាចស្រមៃបាន នេះបង្ហាញពីឱកាសដ៏ធំសម្បើមសម្រាប់កម្មវិធីសាងសង់។ ដោយឆ្លងកាត់អាគុយម៉ង់នៅពេលហៅម៉ាស៊ីនមេដោយប្រើ XMLHttpRequest អ្នកអាចកំណត់ប៉ារ៉ាម៉ែត្រលទ្ធផល ដោយហេតុនេះផ្តល់នូវមុខងារទូលំទូលាយដល់កម្មវិធីបណ្តាញ។

បន្ថែមពីលើ PHP អ្នកអាចប្រើភាសាសរសេរកម្មវិធីចំហៀងម៉ាស៊ីនមេផ្សេងទៀត។

ត្រឡប់មកវិញ៖ jqXHR

អនុវត្តសំណើ HTTP អសមកាលកម្ម (Ajax)

• កំណែបន្ថែម៖ 1.5 jQuery.ajax(url [, settings])

  url
  ប្រភេទ៖ ខ្សែអក្សរ
  URL ដែលសំណើ Ajax នឹងត្រូវបានផ្ញើ

  ការកំណត់
  ប្រភេទ៖ វត្ថុ
  សំណុំនៃប៉ារ៉ាម៉ែត្រ/តម្លៃដែលកំណត់រចនាសម្ព័ន្ធសំណើ Ajax ។ ការកំណត់ទាំងអស់គឺស្រេចចិត្ត។ តាមលំនាំដើម ការកំណត់ត្រូវបានយកចេញពី . ខាងក្រោមនេះគឺជាបញ្ជីពេញលេញនៃការកំណត់ទាំងអស់។

• កំណែបន្ថែម៖ 1.0 jQuery.ajax(ការកំណត់)

  ការកំណត់
  ប្រភេទ៖ វត្ថុ
  សំណុំនៃប៉ារ៉ាម៉ែត្រ/តម្លៃដែលកំណត់រចនាសម្ព័ន្ធសំណើ Ajax ។ ការកំណត់ទាំងអស់គឺស្រេចចិត្ត។ តាមលំនាំដើម ការកំណត់ត្រូវបានយកចេញពី .

ការកំណត់៖

ការកំណត់	ប្រភេទ​ទិន្នន័យ
ទទួលយក លំនាំដើម៖ អាស្រ័យលើប្រភេទទិន្នន័យ នៅពេលធ្វើការស្នើសុំ Ajax បឋមកថាបង្ហាញពីប្រភេទមាតិកាដែលបានអនុញ្ញាតដែលរំពឹងទុកពីម៉ាស៊ីនមេ។ តម្លៃនៃប្រភេទទាំងនេះនឹងត្រូវបានយកចេញពីប៉ារ៉ាម៉ែត្រទទួលយក។ ប្រសិនបើអ្នកត្រូវការផ្លាស់ប្តូរវា វាជាការប្រសើរក្នុងការធ្វើវាដោយប្រើវិធីសាស្ត្រ $.ajaxSetup() ។	វត្ថុមួយ។
អសមកាល លំនាំដើម៖ ពិត តាមលំនាំដើម សំណើទាំងអស់ត្រូវបានផ្ញើដោយអសមកាល (តម្លៃនៃប៉ារ៉ាម៉ែត្រនេះគឺពិត)។ ប្រសិនបើអ្នកត្រូវការសំណើសមកាលកម្ម បន្ទាប់មកកំណត់ប៉ារ៉ាម៉ែត្រ async ទៅជាមិនពិត។ សំណើឆ្លងដែន និងប្រភេទទិន្នន័យ៖ "jsonp" មិនត្រូវបានប្រតិបត្តិក្នុងពេលដំណាលគ្នាទេ។ សូមចំណាំថាសំណើសមកាលកម្មអាចរារាំងកម្មវិធីរុករកខណៈពេលដែលសំណើកំពុងត្រូវបានប្រតិបត្តិ។	ឡូជីខល
មុនពេលផ្ញើ(jqXHR jqXHR, វត្ថុការកំណត់) មុខងារដែលនឹងត្រូវបានហៅភ្លាមៗមុនពេលផ្ញើសំណើ ajax ទៅម៉ាស៊ីនមេ។ វាអាចត្រូវបានប្រើដើម្បីកែប្រែវត្ថុ jqXHR (នៅក្នុងកំណែមុន មុនពេល jQuery 1.4.x, XMLHttpRequest ត្រូវបានប្រើ)។ ក៏អាចប្រើដើម្បីផ្លាស់ប្តូរបឋមកថាជាដើម។ វត្ថុនៃប្រភេទ jqXHR និងវត្ថុការកំណត់ត្រូវបានឆ្លងកាត់ជាអាគុយម៉ង់។ ការត្រឡប់មិនពិតនៅក្នុងអនុគមន៍ beforeSend នឹងបណ្តាលឱ្យសំណើ ajax ត្រូវបានលុបចោល។ ចាប់តាំងពី jQuery 1.5, beforeSend នឹងដំណើរការដោយមិនគិតពីប្រភេទសំណើ។	មុខងារ
ឃ្លាំង​សម្ងាត់ លំនាំដើម៖ ពិត មិនពិតសម្រាប់ប្រភេទទិន្នន័យ "ស្គ្រីប" និង "jsonp" ប្រសិនបើមិនពិត ទំព័រដែលបានស្នើនឹងមិនត្រូវបានដាក់ក្នុងឃ្លាំងសម្ងាត់ដោយកម្មវិធីរុករកទេ។	ឡូជីខល
ពេញលេញ(jqXHR jqXHR, ស្ថានភាពអត្ថបទ) មុខងារ​ដែល​នឹង​ត្រូវ​បាន​ហៅ​បន្ទាប់​ពី​ការ​បំពេញ​សំណើ​របស់ ajax (បាញ់​ចេញ​បន្ទាប់​ពី​ការ​ជោគជ័យ និង​មុខងារ​ដោះស្រាយ​បញ្ហា)។ មុខងារនេះយកអាគុយម៉ង់ពីរ៖ វត្ថុនៃប្រភេទ jqXHR (នៅក្នុងកំណែមុន មុន jQuery 1.4.x, XMLHttpRequest ត្រូវបានប្រើ) និងខ្សែអក្សរដែលបង្ហាញពីស្ថានភាពនៃសំណើ ("ជោគជ័យ", "មិនបានកែប្រែ", "កំហុស", "អស់ពេល ", "បោះបង់" ឬ "parsererror") ។ គិតត្រឹម jQuery 1.5 ពេញលេញអាចទទួលយកអារេនៃមុខងារ។	មុខងារឬអារេ
មាតិកា ប៉ារ៉ាម៉ែត្រត្រូវបានបញ្ជាក់ក្នុងទម្រង់ (ខ្សែអក្សរ៖កន្សោមធម្មតា) ហើយកំណត់ពីរបៀបដែល jQuery នឹងញែកការឆ្លើយតបពីម៉ាស៊ីនមេ អាស្រ័យលើប្រភេទរបស់វា។ (បន្ថែមក្នុងកំណែ 1.5)	វត្ថុមួយ។
ប្រភេទមាតិកា លំនាំដើម៖ "application/x-www-form-urlencoded; charset=UTF-8" នៅពេលផ្ញើសំណើ Ajax ទិន្នន័យត្រូវបានបញ្ជូនតាមទម្រង់ដែលបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រនេះ។ លំនាំដើមគឺ "application/x-www-form-urlencoded; charset=UTF-8"។ ប្រសិនបើអ្នកកំណត់តម្លៃដោយខ្លួនឯង វានឹងបញ្ជូនទៅម៉ាស៊ីនមេ។ ប្រសិនបើការអ៊ិនកូដមិនត្រូវបានបញ្ជាក់ នោះការអ៊ិនកូដលំនាំដើមដែលបានកំណត់នៅលើម៉ាស៊ីនមេនឹងត្រូវបានប្រើ។	បន្ទាត់
បរិបទ វត្ថុដែលនឹងក្លាយជាបរិបទបន្ទាប់ពីការស្នើសុំត្រូវបានបញ្ចប់ (តម្លៃដែលបានបញ្ជូនទៅអថេរនេះ)។ ឧទាហរណ៍ ប្រសិនបើអ្នកបញ្ជាក់ធាតុ DOM ជាបរិបទ នោះអ្នកដោះស្រាយសំណើ ajax ទាំងអស់នឹងត្រូវបានប្រតិបត្តិផងដែរនៅក្នុងបរិបទនៃធាតុ DOM នេះ។ IN ក្នុងឧទាហរណ៍នេះ។ពាក្យគន្លឹះនេះនឹងមាន document.body៖ $.ajax(( url: "test.html", context: document.body, success: function())( $(this).addClass("done"); ) ));	វត្ថុមួយ។
ឧបករណ៍បំប្លែង លំនាំដើម៖ ("*text": window.String, "text html": true, "text json": jQuery.parseJSON, "text xml": jQuery.parseXML) កំណត់មុខងារណាមួយនឹងត្រូវបានប្រើដើម្បីបំប្លែងតម្លៃពីប្រភេទមួយទៅប្រភេទមួយទៀត។ (បន្ថែមក្នុងកំណែ 1.5)	វត្ថុមួយ។
ដែនឆ្លងដែន លំនាំដើម៖ មិនពិតសម្រាប់ដែនដូចគ្នា ពិតសម្រាប់សំណួរឆ្លងដែន។ ប្រសិនបើអ្នកចង់អនុវត្តសំណើឆ្លងដែន (ឧទាហរណ៍ JSONP) នៅលើដែនដូចគ្នា សូមកំណត់ការកំណត់ crossDomain ទៅជាពិត។ ជាឧទាហរណ៍ នេះអនុញ្ញាតឱ្យបញ្ជូនបន្តម៉ាស៊ីនមេទៅកាន់ដែនមួយផ្សេងទៀត។ (បន្ថែមក្នុងកំណែ 1.5)	ឡូជីខល
ទិន្នន័យ ទិន្នន័យដែលនឹងត្រូវបានផ្ទេរទៅម៉ាស៊ីនមេ។ ប្រសិនបើទិន្នន័យមិនមែនជាខ្សែអក្សរ វាត្រូវបានបំប្លែងទៅជាខ្សែអក្សរសំណួរ។ សម្រាប់សំណើ GET ទិន្នន័យត្រូវបានភ្ជាប់ទៅ URL ។ វត្ថុត្រូវតែមានគូសោ/តម្លៃ។ ប្រសិនបើតម្លៃជាអារេ នោះ jQuery បញ្ជាតម្លៃអាស្រ័យលើការកំណត់ប្រពៃណី។ តាមលំនាំដើម ជាឧទាហរណ៍ (foo:["bar1", "bar2"]) ក្លាយជា &foo=bar1&foo=bar2 ។	វត្ថុឬខ្សែអក្សរ
dataFilter(ទិន្នន័យខ្សែអក្សរ ប្រភេទខ្សែអក្សរ) មុខងារដែលនឹងត្រូវបានប្រើដើម្បីដំណើរការទិន្នន័យឆៅនៃប្រភេទ XMLHttpRequest ដែលទទួលបានពីម៉ាស៊ីនមេ។ មុខងាររបស់អ្នកគួរតែដើរតួជាតម្រង ហើយត្រឡប់ខ្សែដែលបានសម្អាត។ ប៉ារ៉ាម៉ែត្រពីរត្រូវបានបញ្ជូនទៅអនុគមន៍៖ ទិន្នន័យដែលទទួលបាន និងតម្លៃនៃប៉ារ៉ាម៉ែត្រប្រភេទទិន្នន័យ។	មុខងារ
ប្រភេទ​ទិន្នន័យ លំនាំដើម៖ ខ្សែអក្សរដែលបានរកឃើញដោយស្វ័យប្រវត្តិ (xml, json, script ឬ html) ប្រភេទទិន្នន័យដែលរំពឹងទុកពីម៉ាស៊ីនមេ។ ប្រសិនបើជម្រើសមិនត្រូវបានបញ្ជាក់ jQuery នឹងព្យាយាមកំណត់ប្រភេទដោយផ្អែកលើប្រភេទ MIME នៃការឆ្លើយតប។	បន្ទាត់
error(jqXHR jqXHR, string textStatus, string errorThrown) មុខងារត្រូវបានប្រតិបត្តិប្រសិនបើសំណើបរាជ័យ។ យកអាគុយម៉ង់ចំនួន 3៖ វត្ថុ jqXHR (អតីត XMLHttpRequest) ខ្សែអក្សរដែលពិពណ៌នាអំពីកំហុស និងខ្សែអក្សរលើកលែងប្រសិនបើវាត្រូវបានបោះចោល។ អាគុយម៉ង់ទីពីរអាចមានតម្លៃដូចខាងក្រោម: null, "អស់ពេល", "error", "abort" និង "parsererror" ។ ប្រសិនបើមានកំហុស HTTP កើតឡើង ស្ថានភាពអត្ថបទរបស់វានឹងត្រូវបានសរសេរទៅកាន់អាគុយម៉ង់ទីបី។ ឧទាហរណ៍ "រកមិនឃើញ" ឬ "កំហុសម៉ាស៊ីនមេខាងក្នុង" ។ ក្នុងនាមជា jQuery 1.5 ជំនួសឱ្យមុខងារតែមួយ ប៉ារ៉ាម៉ែត្រនេះអាចទទួលយកអារេនៃមុខងារ។ ព្រឹត្តិការណ៍កំហុសមិនកើតឡើងនៅពេលដែល dataType ស្មើនឹង script ឬ JSONP ។	មុខងារឬអារេ
សកល លំនាំដើម៖ ពិត។ ថាតើត្រូវហៅទូរសព្ទទៅអ្នកដោះស្រាយព្រឹត្តិការណ៍ Ajax សកលសម្រាប់ការស្នើសុំនេះ (ដូចជា ajaxStart ឬ ajaxStop)។	ឡូជីខល
ក្បាល លំនាំដើម៖ () នៅទីនេះអ្នកអាចបញ្ជាក់បឋមកថាសំណើបន្ថែម។ តម្លៃ​សម្រាប់​ការ​កំណត់​នេះ​នឹង​ត្រូវ​បាន​បញ្ចូល​មុន​ពេល​មុខងារ beforeSend ត្រូវ​បាន​ហៅ ដែល​ការ​ផ្លាស់​ប្តូរ​ចុង​ក្រោយ​ចំពោះ​បឋមកថា​អាច​ត្រូវ​បាន​ធ្វើ​ឡើង។ (បន្ថែមក្នុងកំណែ 1.5)	វត្ថុមួយ។
ប្រសិនបើបានកែប្រែ លំនាំដើម៖ មិនពិត សំណើនឹងត្រូវបានចាត់ទុកថាទទួលបានជោគជ័យតែប៉ុណ្ណោះ ប្រសិនបើទិន្នន័យឆ្លើយតបបានផ្លាស់ប្តូរចាប់តាំងពីការស្នើសុំចុងក្រោយ។ ការត្រួតពិនិត្យត្រូវបានអនុវត្តដោយប្រើបឋមកថាចុងក្រោយដែលបានកែប្រែ។ តាមលំនាំដើម ជម្រើសនេះត្រូវបានបិទ។ នៅក្នុង jQuery 1.4 តម្លៃ "etag" ក៏ត្រូវបានគូសដើម្បីតាមដានថាតើទិន្នន័យបានផ្លាស់ប្តូរដែរឬទេ។	ឡូជីខល
គឺក្នុងស្រុក លំនាំដើម៖ អាស្រ័យលើទីតាំងបច្ចុប្បន្ន ប៉ារ៉ាម៉ែត្រកំណត់ថាតើគេហទំព័រកំពុងដំណើរការក្នុងមូលដ្ឋាន (ឧទាហរណ៍ ការប្រើប្រាស់ឯកសារ *-ផ្នែកបន្ថែម និងពិធីការធាតុក្រាហ្វិក) ឬអត់ (ឧទាហរណ៍ ការប្រើប្រាស់ពិធីការ http)។ វាជាការប្រសើរជាងក្នុងការផ្លាស់ប្តូរការកំណត់នេះដោយប្រើវិធីសាស្ត្រ $.ajaxSetup()។ (បន្ថែមក្នុងកំណែ 1.5)	ឡូជីខល
jsonp កំណត់ឈ្មោះនៃប៉ារ៉ាម៉ែត្រដែលត្រូវបានបន្ថែមទៅ url សំណើ JSONP (តាមលំនាំដើម "ការហៅត្រឡប់មកវិញ" ត្រូវបានប្រើ) ។ ឧទាហរណ៍ ការកំណត់ (jsonp:"onJSONPLoad") ត្រូវបានបំប្លែងទៅជាផ្នែក url នៃខ្សែអក្សរ "onJSONPLoad=?"។ ចាប់តាំងពីកំណែ 1.5 ការបញ្ជាក់មិនពិតនៅក្នុងប៉ារ៉ាម៉ែត្រនេះរារាំងការបន្ថែមប៉ារ៉ាម៉ែត្របន្ថែមទៅ url ។ ក្នុងករណីនេះ អ្នកត្រូវកំណត់តម្លៃកំណត់ jsonpCallback។ ឧទាហរណ៍៖ (jsonp:false, jsonpCallback:"callbackName")។	បន្ទាត់
jsonpCallback មុខងារដែលនឹងត្រូវបានហៅនៅពេលដែលម៉ាស៊ីនមេឆ្លើយតបទៅនឹងសំណើ JSONP ។ តាមលំនាំដើម jQuery បង្កើតឈ្មោះតែមួយគត់ផ្ទាល់ខ្លួនសម្រាប់មុខងារនេះ ដែលល្អជាង។ ប្រសិនបើអ្នកចង់ប្រើឃ្លាំងសម្ងាត់នៃសំណើ GET បន្ទាប់មកបញ្ចូលឈ្មោះមុខងារដោយខ្លួនឯង។ ចាប់ផ្តើមពីកំណែ 1.5 អ្នកអាចបញ្ជាក់មុខងារមួយ ដើម្បីដំណើរការការឆ្លើយតបរបស់ម៉ាស៊ីនមេដោយខ្លួនឯង។	ខ្សែអក្សរឬមុខងារ
ប្រភេទ mime នៅទីនេះអ្នកអាចបញ្ជាក់ប្រភេទទិន្នន័យដែលការឆ្លើយតបត្រូវបានរំពឹងទុកពីម៉ាស៊ីនមេជំនួសឱ្យ XHR ។ (បន្ថែមក្នុងកំណែ 1.5.1)	បន្ទាត់
ពាក្យសម្ងាត់ ពាក្យ​សម្ងាត់​ត្រូវ​ប្រើ​ជា​ការ​ឆ្លើយ​តប​នឹង​សំណើ​ផ្ទៀងផ្ទាត់​ការ​ចូល​ប្រើប្រាស់ HTTP (បើ​ចាំបាច់)	បន្ទាត់
ឈ្មោះ​អ្នកប្រើប្រាស់ ឈ្មោះ​អ្នក​ប្រើ​ដែល​នឹង​ត្រូវ​បាន​ប្រើ​ក្នុង​ការ​ឆ្លើយ​តប​ទៅ​នឹង​សំណើ​ផ្ទៀងផ្ទាត់​ការ​ចូល​ដំណើរ​ការ HTTP (បើ​ចាំបាច់)	បន្ទាត់
ទិន្នន័យដំណើរការ លំនាំដើម៖ ពិត ; តាមលំនាំដើម ទិន្នន័យដែលបានបញ្ជូនទៅម៉ាស៊ីនមេត្រូវបានបំប្លែងពីវត្ថុមួយទៅជាខ្សែអក្សរសំណួរ ហើយផ្ញើជា "application/x-www-form-urlencoded"។ ប្រសិនបើអ្នកត្រូវការផ្ញើឯកសារ DOM ឬទិន្នន័យផ្សេងទៀតដែលមិនអាចបំប្លែងបាន សូមកំណត់ជម្រើសដំណើរការទិន្នន័យទៅជាមិនពិត។	ឡូជីខល
scriptCharset អនុវត្តចំពោះសំណើ Ajax GET នៃប្រភេទ "JSONP" និង "script" ប៉ុណ្ណោះ។ ប្រសិនបើម៉ាស៊ីនមេនៅលើដែនភាគីទីបីប្រើការអ៊ិនកូដដែលខុសពីរបស់អ្នក អ្នកត្រូវតែបញ្ជាក់ការអ៊ិនកូដរបស់ម៉ាស៊ីនមេភាគីទីបី។	បន្ទាត់
លេខកូដស្ថានភាព លំនាំដើម៖ () សំណុំនៃគូដែលលេខកូដប្រតិបត្តិត្រូវបានភ្ជាប់ជាមួយមុខងារដែលនឹងត្រូវបានហៅ។ ឧទាហរណ៍ សម្រាប់លេខកូដ 404 (ទំព័រមិនមាន) អ្នកអាចបង្ហាញសារនៅលើអេក្រង់៖ $.ajax(( statusCode:( 404:function())( alert("Page not found"); ) ) )); ប្រសិនបើសំណើបានជោគជ័យ នោះជាប៉ារ៉ាម៉ែត្រ មុខងារអនាមិកនឹងយកប៉ារ៉ាម៉ែត្រដូចគ្នាទៅនឹងភាពជោគជ័យ។ ប្រសិនបើមានកំហុស វានឹងដំណើរការដូចគ្នាជាមួយនឹងមុខងារដោះស្រាយកំហុស។ (បន្ថែមក្នុងកំណែ 1.5)	វត្ថុមួយ។
ជោគជ័យ(វត្ថុទិន្នន័យ ខ្សែអក្សរស្ថានភាពអត្ថបទ វត្ថុ jqXHR) មុខងារដែលនឹងត្រូវបានហៅប្រសិនបើសំណើបានបញ្ចប់ដោយជោគជ័យ។ យកអាគុយម៉ង់ចំនួន 3 - ទិន្នន័យដែលបានផ្ញើដោយម៉ាស៊ីនមេនិងដំណើរការជាមុន; ខ្សែអក្សរដែលមានស្ថានភាពប្រតិបត្តិ (ស្ថានភាពអត្ថបទ); វត្ថុ jqXHR (នៅក្នុងកំណែមុន 1.5, XMLHttpRequest ត្រូវបានប្រើជំនួសឱ្យ jqXHR) ។ ក្នុងនាមជា jQuery 1.5 ជំនួសឱ្យមុខងារតែមួយ ប៉ារ៉ាម៉ែត្រនេះអាចទទួលយកអារេនៃមុខងារ។	មុខងារឬអារេ
ដល់​ម៉ោង ពេលវេលារង់ចាំសម្រាប់ការឆ្លើយតបពីម៉ាស៊ីនមេគិតជាមិល្លីវិនាទី។ សរសេរជាន់លើការកំណត់សកលនៃប៉ារ៉ាម៉ែត្រដូចគ្នានៅក្នុង $.ajaxSetup() ។ ប្រសិនបើពេលវេលានេះលើស សំណើនឹងបរាជ័យ ហើយព្រឹត្តិការណ៍បញ្ហានឹងកើតឡើងជាមួយនឹងស្ថានភាព "អស់ពេល"។	ចំនួន
ប្រពៃណី លំនាំដើម៖ មិនពិត កំណត់ប៉ារ៉ាម៉ែត្រនេះទៅពិត ដើម្បីប្រើរចនាប័ទ្មសៀរៀលប្រពៃណី។	ឡូជីខល
ប្រភេទ លំនាំដើម៖ ទទួល កំណត់ថាតើសំណើគឺ GET ឬ POST ។ អ្នកក៏អាចប្រើសំណើ HTTP ផ្សេងទៀត (ដូចជា PUT ឬ DELETE) ប៉ុន្តែត្រូវដឹងថា មិនមែនគ្រប់ browsers ទាំងអស់គាំទ្រពួកវាទេ។	បន្ទាត់
url លំនាំដើម៖ ទំព័របច្ចុប្បន្ន។ ទំព័រដែលសំណើនឹងត្រូវបានផ្ញើ។	បន្ទាត់
xhr តាមលំនាំដើម ActiveXObject នៅក្នុង IE, XMLHttpRequest នៅក្នុងកម្មវិធីរុករកផ្សេងទៀត។ មុខងារ Callback ដើម្បីបង្កើតវត្ថុ XMLHttpRequest ។ តាមរយៈការបង្កើតមុខងាររបស់អ្នក អ្នកទទួលខុសត្រូវទាំងស្រុងចំពោះការបង្កើតវត្ថុ។	មុខងារ
xhrFields វត្ថុនៃទម្រង់បែបបទ (ឈ្មោះ៖ តម្លៃ) សម្រាប់ការផ្លាស់ប្តូរតម្លៃនៃវាលដែលត្រូវគ្នានៃវត្ថុ XMLHttpRequest ។ $.ajax(( url: a_cross_domain_url, xhrFields: ( with Credentials: true ) )); (បន្ថែមក្នុងកំណែ 1.5.1)	ផែនទី

$.ajax(( type: "POST", url: "some.php", data: ( name: "John", location: "Boston" ))).done(function(msg)( alert("Data Saved: " + សារ); ));

ទទួលបាន ជំនាន់​ចុងក្រោយទំព័រ HTML

$.ajax(( url: "test.html", cache: false )).done(function(html)( $("#results").append(html); ));

យើងបញ្ជូនឯកសារ XML ជាទិន្នន័យ។ បិទការបម្លែងទិន្នន័យដោយស្វ័យប្រវត្តិទៅជា ខ្សែធម្មតា។កំណត់ដំណើរការកំណត់ទិន្នន័យទៅជាមិនពិត៖

var xmlDocument = ; var xmlRequest = $.ajax(( url: "page.php", processData: false, data: xmlDocument )); xmlRequest.done(handleResponse);

Var menuId = $("ul.nav").first().attr("id"); var request = $.ajax(( url: "script.php", type: "POST", data: (id: menuId), dataType: "html" )); request.done(function(msg)($("#log").html(msg); )); request.fail(function(jqXHR, textStatus) ( alert("Request failed: " + textStatus); ));

ផ្ទុក និងប្រតិបត្តិឯកសារ JavaScript៖

$.ajax((ប្រភេទ៖ "GET", url: "test.js", dataType: "script" ));

ធ្វើសំណើទៅម៉ាស៊ីនមេដោយមិនផ្ទុកទំព័រឡើងវិញ។ នេះគឺជាវិធីសាស្ត្រកម្រិតទាបដែលមានការកំណត់ជាច្រើន។ វាបញ្ជាក់ពីប្រតិបត្តិការនៃវិធីសាស្រ្ត ajax ផ្សេងទៀតទាំងអស់។ មានជម្រើសប្រើប្រាស់ពីរ៖

url - ស្នើសុំអាសយដ្ឋាន។
ការកំណត់ - នៅក្នុងប៉ារ៉ាម៉ែត្រនេះ អ្នកអាចបញ្ជាក់ការកំណត់សម្រាប់សំណើនេះ។ បញ្ជាក់ដោយប្រើវត្ថុក្នុងទម្រង់ (ឈ្មោះ៖ តម្លៃ ឈ្មោះ៖ តម្លៃ...) ។ គ្មានការកំណត់ណាមួយត្រូវបានទាមទារទេ។ អ្នកអាចកំណត់ការកំណត់លំនាំដើមដោយប្រើវិធីសាស្ត្រ $.ajaxSetup()។

បញ្ជីការកំណត់

↓ ឈ្មោះ៖ ប្រភេទ (តម្លៃលំនាំដើម)

នៅពេលសំណើត្រូវបានធ្វើឡើង បឋមកថាបង្ហាញពីប្រភេទមាតិកាដែលបានអនុញ្ញាតដែលរំពឹងទុកពីម៉ាស៊ីនមេ។ តម្លៃនៃប្រភេទទាំងនេះនឹងត្រូវបានយកចេញពីប៉ារ៉ាម៉ែត្រទទួលយក។

តាមលំនាំដើម សំណើទាំងអស់ដោយគ្មានការផ្ទុកទំព័រឡើងវិញកើតឡើងដោយអសមកាល (នោះគឺបន្ទាប់ពីផ្ញើសំណើទៅម៉ាស៊ីនមេ ទំព័រមិនឈប់ដំណើរការទេ ខណៈពេលដែលរង់ចាំការឆ្លើយតប)។ ប្រសិនបើអ្នកត្រូវការប្រតិបត្តិសំណើដោយសមកាលកម្ម បន្ទាប់មកកំណត់ប៉ារ៉ាម៉ែត្រទៅជាមិនពិត។ សំណើឆ្លងដែន និង "jsonp" មិនអាចប្រតិបត្តិក្នុងទម្រង់សមកាលកម្មបានទេ។

សូម​ដឹង​ថា​ការ​ប្រតិបត្តិ​សំណើ​ក្នុង​ទម្រង់​សមកាលកម្ម​អាច​នឹង​ធ្វើ​ឱ្យ​ទំព័រ​ត្រូវ​បាន​រារាំង​រហូត​ដល់​សំណើ​ត្រូវ​បាន​បញ្ចប់​ពេញលេញ។

វាលនេះមានមុខងារដែលនឹងត្រូវបានហៅភ្លាមៗមុនពេលផ្ញើសំណើ ajax ទៅម៉ាស៊ីនមេ។ មុខងារនេះអាចមានប្រយោជន៍សម្រាប់ការកែប្រែវត្ថុ jqXHR (នៅក្នុងកំណែមុននៃបណ្ណាល័យ (រហូតដល់ 1.5) XMLHttpRequest ត្រូវបានប្រើជំនួសឱ្យ jqXHR) ។ ឧទាហរណ៍ អ្នកអាចផ្លាស់ប្តូរ/បញ្ជាក់បឋមកថាចាំបាច់។ល។ វត្ថុ jqXHR នឹងត្រូវបានបញ្ជូនទៅមុខងារជាអាគុយម៉ង់ដំបូង។ អាគុយម៉ង់ទីពីរគឺការកំណត់សំណើ។

នៅក្នុងវាលនេះ អ្នកអាចបញ្ជាក់បឋមកថាសំណើបន្ថែម។ ការផ្លាស់ប្តូរទាំងនេះនឹងត្រូវបានបញ្ចូលមុនពេលបញ្ជូនត្រូវបានហៅ ដែលការកែសម្រួលបឋមកថាចុងក្រោយអាចត្រូវបានធ្វើឡើង។

នៅពេលដែលការកំណត់នេះត្រូវបានកំណត់ទៅពិត សំណើនឹងត្រូវបានប្រតិបត្តិជាមួយនឹងស្ថានភាព "ជោគជ័យ" លុះត្រាតែការឆ្លើយតបពីម៉ាស៊ីនមេខុសពីការឆ្លើយតបពីមុន។ jQuery ពិនិត្យការពិតនេះដោយមើលបឋមកថាចុងក្រោយដែលបានកែប្រែ។ ចាប់តាំងពី jQuery-1.4 បន្ថែមពីលើ Last-Modified "etag" ក៏ត្រូវបានគូសធីកផងដែរ (ពួកវាទាំងពីរត្រូវបានផ្តល់ដោយម៉ាស៊ីនមេ ហើយចាំបាច់ដើម្បីជូនដំណឹងដល់កម្មវិធីរុករកតាមអ៊ីនធឺណិតថាទិន្នន័យដែលបានស្នើសុំពីម៉ាស៊ីនមេមិនត្រូវបានផ្លាស់ប្តូរពីសំណើពីមុនទេ) .

អនុញ្ញាត​ឱ្យ​អ្នក​កំណត់​ស្ថានភាព​ប្រភព​នៃ​ទំព័រ​ទៅ​មូលដ្ឋាន (ដូច​ជា​វា​លើស​ពិធីការ​ឯកសារ) ទោះបីជា jQuery បាន​ទទួល​ស្គាល់​វា​បើ​មិន​ដូច្នេះ​ទេ​។ បណ្ណាល័យសម្រេចថាទំព័រកំពុងដំណើរការក្នុងមូលដ្ឋានក្នុងករណីនៃពិធីការខាងក្រោម៖ ឯកសារ *-ផ្នែកបន្ថែម និងធាតុក្រាហ្វិក។

វាត្រូវបានណែនាំឱ្យកំណត់តម្លៃប៉ារ៉ាម៉ែត្រ គឺក្នុងស្រុកជាសកល - ដោយប្រើមុខងារ $.ajaxSetup() ហើយមិនមែននៅក្នុងការកំណត់នៃសំណើ ajax នីមួយៗទេ។

កំណត់ឈ្មោះនៃប៉ារ៉ាម៉ែត្រដែលត្រូវបានបន្ថែមទៅ url កំឡុងពេលស្នើសុំ jsonp (តាមលំនាំដើម "callback" ត្រូវបានប្រើ - "http://siteName.ru?callback=...") ។

ចាប់ពី jQuery-1.5 ការកំណត់ប៉ារ៉ាម៉ែត្រនេះទៅមិនពិតនឹងការពារប៉ារ៉ាម៉ែត្របន្ថែមពីការបន្ថែមទៅ url ។ ក្នុងករណីនេះ អ្នកត្រូវតែកំណត់តម្លៃនៃទ្រព្យសម្បត្តិ jsonpCallback ឱ្យបានច្បាស់លាស់។ ឧទាហរណ៍៖ (jsonp:false, jsonpCallback:"callbackName")។

កំណត់ឈ្មោះមុខងារដែលនឹងត្រូវបានហៅនៅពេលដែលម៉ាស៊ីនមេឆ្លើយតបទៅនឹងសំណើ jsonp ។ តាមលំនាំដើម jQuery បង្កើតឈ្មោះផ្ទាល់ខ្លួនសម្រាប់មុខងារនេះ ដែលជាជម្រើសល្អដែលជួយសម្រួលដល់ការងាររបស់បណ្ណាល័យ។ ហេតុផលមួយក្នុងចំណោមហេតុផលដើម្បីបញ្ជាក់មុខងារដំណើរការសំណើ jsonp ផ្ទាល់ខ្លួនរបស់អ្នកគឺដើម្បីកែលម្អឃ្លាំងសម្ងាត់នៃសំណើ GET ។

ចាប់ពី jQuery-1.5 អ្នកអាចបញ្ជាក់មុខងារនៅក្នុងប៉ារ៉ាម៉ែត្រនេះ ដើម្បីគ្រប់គ្រងការឆ្លើយតបរបស់ម៉ាស៊ីនមេដោយខ្លួនឯង។ ក្នុងករណីនេះមុខងារដែលបានបញ្ជាក់ត្រូវតែត្រឡប់ទិន្នន័យដែលទទួលបានពីម៉ាស៊ីនមេ (នៅក្នុងមុខងារដែលបានបញ្ជាក់វានឹងមាននៅក្នុងប៉ារ៉ាម៉ែត្រទីមួយ)។

តាមលំនាំដើម ទិន្នន័យទាំងអស់ដែលបានបញ្ជូនទៅកាន់ម៉ាស៊ីនមេត្រូវបានបំប្លែងជាមុនទៅជាខ្សែអក្សរ (ទម្រង់ url៖ fName1=value1&fName2=value2&...) ដែលត្រូវគ្នាទៅនឹង "application/x-www-form-urlencoded" ។ ប្រសិនបើអ្នកត្រូវការផ្ញើទិន្នន័យដែលមិនអាចទទួលរងនូវដំណើរការបែបនេះ (ឧទាហរណ៍ ឯកសារ DOM) នោះអ្នកគួរតែបិទជម្រើសដំណើរការទិន្នន័យ។

ប៉ារ៉ាម៉ែត្រនេះត្រូវបានប្រើសម្រាប់សំណើឆ្លងដែន ajax នៃប្រភេទ GET ប្រភេទទិន្នន័យអាចជា "jsonp" ឬ "script" ។ កំណត់ការអ៊ិនកូដដែលសំណើឆ្លងដែននឹងត្រូវបានប្រតិបត្តិ។ វាចាំបាច់ប្រសិនបើម៉ាស៊ីនមេនៅលើដែនបរទេសប្រើការអ៊ិនកូដដែលខុសពីការអ៊ិនកូដនៅលើម៉ាស៊ីនមេនៃដែនដើមរបស់វា។

(ការកំណត់នេះត្រូវបានណែនាំនៅក្នុង jQuery-1.5)សំណុំនៃគូដែលលេខកូដប្រតិបត្តិត្រូវបានភ្ជាប់ជាមួយមុខងារដែលនឹងត្រូវបានហៅ។ ឧទាហរណ៍ សម្រាប់លេខកូដ 404 (ទំព័រមិនមាន) អ្នកអាចបង្ហាញសារនៅលើអេក្រង់៖

$.ajax (( statusCode: ( 404 : function () ( alert ( "Page not found" ); ) ) );

មុខងារដែលឆ្លើយតបទៅនឹងសំណើកូដជោគជ័យនឹងទទួលបានអាគុយម៉ង់ដូចគ្នានឹងមុខងារដោះស្រាយសំណើជោគជ័យ (បានបញ្ជាក់ក្នុងប៉ារ៉ាម៉ែត្រជោគជ័យ) ហើយមុខងារដែលឆ្លើយតបទៅនឹងលេខកូដកំហុសនឹងដូចគ្នាទៅនឹងមុខងារដែលមានកំហុសដែរ។

មុខងារដែលនឹងត្រូវបានហៅប្រសិនបើសំណើទៅកាន់ម៉ាស៊ីនមេបានបញ្ចប់ដោយជោគជ័យ។ វានឹងត្រូវបានឆ្លងកាត់ប៉ារ៉ាម៉ែត្រចំនួនបី៖ ទិន្នន័យដែលបានផ្ញើដោយម៉ាស៊ីនមេ និងត្រូវបានដំណើរការជាមុនរួចហើយ (ដែលខុសគ្នាសម្រាប់ប្រភេទទិន្នន័យផ្សេងៗគ្នា)។ ប៉ារ៉ាម៉ែត្រទីពីរគឺជាខ្សែដែលមានស្ថានភាពប្រតិបត្តិ។ ប៉ារ៉ាម៉ែត្រទីបីមានវត្ថុ jqXHR (នៅក្នុងកំណែមុននៃបណ្ណាល័យ (រហូតដល់ 1.5) XMLHttpRequest ត្រូវបានប្រើជំនួសឱ្យ jqXHR) ។ ក្នុងនាមជា jQuery-1.5 ជំនួសឱ្យមុខងារតែមួយ ប៉ារ៉ាម៉ែត្រនេះអាចទទួលយកអារេនៃអនុគមន៍។

រង់ចាំពេលវេលាសម្រាប់ការឆ្លើយតបពីម៉ាស៊ីនមេ។ កំណត់ជាមីលីវិនាទី។ ប្រសិនបើពេលវេលានេះលើស សំណើនឹងត្រូវបានបញ្ចប់ដោយមានកំហុស ហើយព្រឹត្តិការណ៍កំហុសនឹងកើតឡើង (សូមមើលការពិពណ៌នាខាងលើ) ដែលនឹងមានស្ថានភាព "អស់ពេល"។

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

នៅក្នុង jQuery-1.4 និងមុននេះ នៅពេលដែលវត្ថុ XMLHttpRequest អស់ពេល វានឹងចូលទៅក្នុងស្ថានភាពកំហុស ហើយការចូលប្រើវាលរបស់វាអាចនឹងមានការលើកលែងមួយ។ នៅក្នុង Firefox 3.0+ សំណើស្គ្រីប និង JSONP នឹងមិនត្រូវបានលុបចោលទេ ប្រសិនបើពួកគេអស់ពេល។ ពួកគេនឹងត្រូវបានបញ្ចប់សូម្បីតែបន្ទាប់ពីពេលវេលានេះបានផុតកំណត់។

មុខងារដែលនឹងផ្តល់នូវវត្ថុ XMLHttpRequest ។ តាមលំនាំដើម សម្រាប់កម្មវិធីរុករក IE វត្ថុនេះគឺជា ActiveXObject ហើយក្នុងករណីផ្សេងទៀតវាគឺជា XMLHttpRequest ។ ជាមួយនឹងជម្រើសនេះ អ្នកអាចអនុវត្តកំណែផ្ទាល់ខ្លួនរបស់អ្នកនៃវត្ថុនេះ។

(ការកំណត់នេះត្រូវបានណែនាំនៅក្នុង jQuery-1.5.1)សំណុំនៃ (ឈ្មោះ៖ តម្លៃ) គូសម្រាប់ការផ្លាស់ប្តូរ/បន្ថែមតម្លៃនៃវាលដែលត្រូវគ្នានៃវត្ថុ XMLHttpRequest ។ ជាឧទាហរណ៍ អ្នកអាចកំណត់លក្ខណៈសម្បតិ្តអត្តសញ្ញាណប័ណ្ណរបស់វាទៅជាពិត នៅពេលប្រតិបត្តិសំណើឆ្លងដែន៖

$.ajax (( url: a_cross_domain_url, xhrFields: ( with Credentials: true ) ) );

នៅក្នុង jQuery-1.5 លក្ខណៈសម្បត្តិ withCredentials មិនត្រូវបានគាំទ្រដោយ XMLHttpRequest ដើមឡើយ ហើយនឹងត្រូវបានមិនអើពើនៅក្នុងសំណើឆ្លងដែន។ វាត្រូវបានជួសជុលនៅក្នុងកំណែបន្តបន្ទាប់ទាំងអស់នៃបណ្ណាល័យ។

អ្នកដោះស្រាយព្រឹត្តិការណ៍

មុនពេលផ្ញើ កំហុស តម្រងទិន្នន័យ ជោគជ័យ និងការកំណត់ពេញលេញ (ការពិពណ៌នារបស់ពួកគេគឺនៅក្នុងផ្នែកមុន) អនុញ្ញាតឱ្យអ្នកកំណត់កម្មវិធីដោះស្រាយព្រឹត្តិការណ៍ដែលកើតឡើងនៅចំណុចជាក់លាក់ក្នុងការប្រតិបត្តិនៃសំណើ ajax នីមួយៗ។

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

ឧទាហរណ៍ ងាយស្រួល​ប្រើ. យើងនឹងបង្ហាញសារនៅពេលសំណើត្រូវបានបញ្ចប់ដោយជោគជ័យ៖

$.ajax (( url: "ajax/test.html", ជោគជ័យ: function () ( alert ("Load was performed." ); ) );

ដោយចាប់ផ្តើមជាមួយ jQuery-1.5 វិធីសាស្ត្រ $.ajax() ត្រឡប់វត្ថុ jqXHR ដែលក្នុងចំណោមរបស់ផ្សេងទៀត អនុវត្តចំណុចប្រទាក់ពន្យារ ដែលអនុញ្ញាតឱ្យអ្នកបញ្ជាក់ឧបករណ៍ដោះស្រាយការប្រតិបត្តិបន្ថែម។ បន្ថែមពីលើវិធីសាស្ត្រ .done(), .fail() និង .then() សម្រាប់វត្ថុដែលបានពន្យារពេល ដែលអ្នកអាចដំឡើងកម្មវិធីដោះស្រាយ jqXHR អនុវត្ត .success(), .error() និង .complete() ។ នេះត្រូវបានធ្វើដើម្បីអនុលោមតាមឈ្មោះធម្មតានៃវិធីសាស្រ្តដែលអ្នកដោះស្រាយសម្រាប់ការប្រតិបត្តិសំណើ ajax ត្រូវបានដំឡើង។ ទោះយ៉ាងណាក៏ដោយ គិតត្រឹម jQuery-1.8 វិធីសាស្ត្រទាំងបីនេះនឹងត្រូវបានបដិសេធ។

ប្រភេទសំណើមួយចំនួនដូចជា jsonp ឬ cross-domain GET requests មិនគាំទ្រការប្រើប្រាស់វត្ថុ XMLHttpRequest ទេ។ ក្នុងករណីនេះ XMLHttpRequest និង textStatus ដែលបានបញ្ជូនទៅអ្នកដោះស្រាយនឹងមានតម្លៃដែលមិនបានកំណត់។

នៅខាងក្នុងឧបករណ៍ដោះស្រាយ អថេរនេះនឹងមានតម្លៃនៃប៉ារ៉ាម៉ែត្រ បរិបទ. ក្នុងករណីដែលវាមិនត្រូវបានកំណត់ វានឹងមានវត្ថុការកំណត់។

ប៉ារ៉ាម៉ែត្រប្រភេទទិន្នន័យ

មុខងារ $.ajax() រៀនអំពីប្រភេទទិន្នន័យដែលផ្ញើដោយម៉ាស៊ីនមេពីម៉ាស៊ីនមេខ្លួនឯង (តាមរយៈ MIME)។ លើសពីនេះ មានឱកាសដើម្បីបង្ហាញដោយផ្ទាល់ (បញ្ជាក់) ពីរបៀបដែលទិន្នន័យទាំងនេះគួរតែត្រូវបានបកស្រាយ។ នេះត្រូវបានធ្វើដោយប្រើប៉ារ៉ាម៉ែត្រ dataType ។ តម្លៃដែលអាចធ្វើបានសម្រាប់ប៉ារ៉ាម៉ែត្រនេះ៖

"xml"- លទ្ធផលឯកសារ xml នឹងមានជាទម្រង់អត្ថបទ។ អ្នកអាចធ្វើការជាមួយវាដោយប្រើឧបករណ៍ jQuery ស្តង់ដារ (ក៏ដូចជាឯកសារ html) ។ "html"- លទ្ធផល html នឹងមានជាទម្រង់អត្ថបទ។ ប្រសិនបើវាមានស្គ្រីបនៅក្នុងស្លាក នោះពួកវានឹងត្រូវបានប្រតិបត្តិដោយស្វ័យប្រវត្តិនៅពេលដែលអត្ថបទ html ត្រូវបានដាក់ក្នុង DOM ប៉ុណ្ណោះ។ "ស្គ្រីប"- ទិន្នន័យដែលទទួលបាននឹងត្រូវបានប្រតិបត្តិជា javascript ។ អថេរដែលជាធម្មតាមានការឆ្លើយតបពីម៉ាស៊ីនមេនឹងមានវត្ថុ jqXHR ។ "json", "jsonp"- ទិន្នន័យដែលទទួលបាននឹងត្រូវបានបំប្លែងជាមុនទៅជាវត្ថុ javascript ។ ប្រសិនបើការវិភាគបរាជ័យ (ដែលអាចកើតឡើងប្រសិនបើ json មានកំហុស) នោះការលើកលែងកំហុសក្នុងការញែកឯកសារនឹងត្រូវបានបោះចោល។ ប្រសិនបើម៉ាស៊ីនមេដែលអ្នកកំពុងចូលប្រើគឺនៅលើដែនផ្សេងនោះ jsonp គួរតែត្រូវបានប្រើជំនួសឱ្យ json ។ អ្នកអាចស្វែងយល់អំពី json និង jsonp នៅលើ Wikipedia ។ "អត្ថបទ"- ទិន្នន័យដែលទទួលបាននឹងមានជាអត្ថបទធម្មតា ដោយមិនចាំបាច់ដំណើរការបឋម។

ចំណាំ ១៖ នៅពេលដែលសំណើត្រូវបានផ្ញើទៅកាន់ដែនភាគីទីបី (ដែលអាចធ្វើទៅបានតែជាមួយ dataType ស្មើនឹង jsonp ឬ script) នោះ error handler និងព្រឹត្តិការណ៍សកលនឹងមិនដំណើរការទេ។

ចំណាំ ២៖ ប្រភេទទិន្នន័យដែលបានបញ្ជាក់នៅក្នុង dataType មិនត្រូវប៉ះទង្គិចជាមួយព័ត៌មាន MIME ដែលផ្តល់ដោយម៉ាស៊ីនមេទេ។ ឧទាហរណ៍ ទិន្នន័យ xml ត្រូវ​តែ​តំណាង​ដោយ​ម៉ាស៊ីន​បម្រើ​ជា text/xml ឬ application/xml ។ ប្រសិនបើវាបរាជ័យ jquery នឹងព្យាយាមបំប្លែងទិន្នន័យដែលទទួលបានទៅជាប្រភេទដែលបានបញ្ជាក់ (បន្ថែមលើវានៅក្នុងផ្នែក Converters)។

ការបញ្ជូនទិន្នន័យទៅម៉ាស៊ីនមេ

តាមលំនាំដើម សំណើទៅកាន់ម៉ាស៊ីនមេត្រូវបានធ្វើឡើងដោយប្រើវិធីសាស្ត្រ HTTP GET។ ប្រសិនបើអ្នកត្រូវការធ្វើសំណើដោយប្រើវិធីសាស្ត្រ POST អ្នកត្រូវបញ្ជាក់តម្លៃសមស្របនៅក្នុងការកំណត់ប្រភេទ។ ទិន្នន័យដែលបានផ្ញើដោយប្រើវិធីសាស្ត្រ POST នឹងត្រូវបានបំប្លែងទៅជា UTF-8 ប្រសិនបើវាស្ថិតនៅក្នុងការបំប្លែងកូដផ្សេង ដូចដែលតម្រូវដោយស្តង់ដារ W3C XMLHTTPRequest។

ប៉ារ៉ាម៉ែត្រទិន្នន័យអាចត្រូវបានបញ្ជាក់ទាំងជាខ្សែអក្សរក្នុងទម្រង់ key1=value1&key2=value2 (ទម្រង់ផ្ទេរទិន្នន័យក្នុង url) ឬជាវត្ថុដែលមានសំណុំ (ឈ្មោះ៖ តម្លៃ) គូ - (key1: "value1", key2: "តម្លៃ 2") ។ ក្នុងករណីចុងក្រោយ មុនពេលផ្ញើទិន្នន័យ jQuery បំប្លែងវត្ថុដែលបានផ្តល់ឱ្យទៅជាខ្សែអក្សរដោយប្រើ $.param() ។ ទោះយ៉ាងណាក៏ដោយ ការបំប្លែងនេះអាចត្រឡប់វិញបានដោយការកំណត់ដំណើរការទិន្នន័យទៅជាមិនពិត។ ការបំប្លែងទៅជាខ្សែអក្សរគឺមិនចង់បានទេ ឧទាហរណ៍ក្នុងករណីផ្ញើវត្ថុ xml ទៅម៉ាស៊ីនមេ។ ក្នុងករណីនេះ គួរតែផ្លាស់ប្តូរការកំណត់ប្រភេទមាតិកាពី application/x-www-form-urlencodedទៅប្រភេទ mime ដែលសមរម្យជាង។

មតិយោបល់៖កម្មវិធីរុករកតាមអ៊ីនធឺណិតភាគច្រើនមិនអនុញ្ញាតឱ្យ Ajax ស្នើសុំធនធានដែលមានដែន ដែនរង និងពិធីការក្រៅពីកម្មវិធីបច្ចុប្បន្នទេ។ ទោះយ៉ាងណាក៏ដោយ ការកំណត់នេះមិនអនុវត្តចំពោះសំណើ jsonp និង script ទេ។

ការទទួលទិន្នន័យពីម៉ាស៊ីនមេ

ទិន្នន័យដែលទទួលបានពីម៉ាស៊ីនមេអាចត្រូវបានផ្តល់ជាខ្សែអក្សរ ឬវត្ថុមួយ អាស្រ័យលើតម្លៃនៃប៉ារ៉ាម៉ែត្រប្រភេទទិន្នន័យ (សូមមើលប្រភេទទិន្នន័យខាងលើ)។ ទិន្នន័យនេះតែងតែមាននៅក្នុងប៉ារ៉ាម៉ែត្រដំបូងនៃកម្មវិធីដោះស្រាយការប្រតិបត្តិសំណើ ajax៖

$.ajax (( url: "some.php", success: function (data) ( alert ( "Profit data: " + data ); ) );

សម្រាប់ប្រភេទអត្ថបទ និង xml ទិន្នន័យដែលបានផ្ញើដោយម៉ាស៊ីនមេក៏នឹងមាននៅក្នុង jqXHR ផងដែរ ពោលគឺនៅក្នុងវាលឆ្លើយតបអត្ថបទ ឬការឆ្លើយតបXML រៀងៗខ្លួន។

ការកំណត់កម្រិតខ្ពស់

ដោយប្រើប៉ារ៉ាម៉ែត្រសកល អ្នកអាចបិទដំណើរការកម្មវិធីដោះស្រាយព្រឹត្តិការណ៍ (.ajaxSend(), .ajaxError() ។ល។) សម្រាប់សំណើនីមួយៗ។ វាអាចមានប្រយោជន៍ ជាឧទាហរណ៍ ប្រសិនបើការផ្ទុកចលនាត្រូវបានចាប់ផ្តើម/បញ្ឈប់នៅក្នុងឧបករណ៍ដោះស្រាយទាំងនេះ។ បន្ទាប់មក ប្រសិនបើសំណើមួយចំនួនត្រូវបានប្រតិបត្តិញឹកញាប់ និងឆាប់រហ័ស នោះវានឹងមានប្រយោជន៍សម្រាប់ពួកគេក្នុងការបិទដំណើរការប្រតិបត្តិរបស់ឧបករណ៍ដោះស្រាយ។ សម្រាប់សំណើឆ្លងដែន និង jsonp ប៉ារ៉ាម៉ែត្រសកលត្រូវបានបិទដោយស្វ័យប្រវត្តិ។

ប្រសិនបើទិន្នន័យផ្ទៀងផ្ទាត់ (ចូល/ពាក្យសម្ងាត់) ត្រូវបានទាមទារដើម្បីធ្វើសំណើទៅកាន់ម៉ាស៊ីនមេ នោះអ្នកអាចបញ្ជាក់វានៅក្នុងការកំណត់ឈ្មោះអ្នកប្រើប្រាស់ និងពាក្យសម្ងាត់នៃសំណើ ajax។

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

វាអាចកើតឡើងដែលការអ៊ិនកូដម៉ាស៊ីនខុសពីការអ៊ិនកូដនៃឯកសារ javascript ដែលបានស្នើសុំនៅក្នុងសំណើ ajax ។ ក្នុង​ករណី​បែប​នេះ វា​ជា​ការ​ចាំបាច់​ដើម្បី​បញ្ជាក់​ការ​បំប្លែង​កូដ​ក្រោយ​ក្នុង​ការ​កំណត់ scriptCharset ។

ក្នុងករណីភាគច្រើន សំណើ Ajax កើតឡើងដោយអសមកាល ប៉ុន្តែក្នុងករណីខ្លះ វាអាចចាំបាច់ដើម្បីប្រតិបត្តិសំណើតាមលំដាប់លំដោយ (នៅពេលដែលការប្រតិបត្តិស្គ្រីបបន្ថែមទៀតគឺមិនអាចទៅរួចដោយមិនទទួលបានការឆ្លើយតបពីម៉ាស៊ីនមេ)។ អ្នកអាចធ្វើឱ្យសំណើសមកាលកម្ម ប្រសិនបើអ្នកបិទការកំណត់អសមកាល។ ទោះជាយ៉ាងណាក៏ដោយវាគួរអោយចងចាំថាក្នុងករណីនេះទំព័រនឹងបង្កកខណៈពេលដែលរង់ចាំការឆ្លើយតបពីម៉ាស៊ីនមេ។

ឧទាហរណ៍នៃការប្រើប្រាស់

ករណីប្រើប្រាស់សាមញ្ញបំផុតគឺការហៅ $.ajax() ដោយមិនបញ្ជាក់ប៉ារ៉ាម៉ែត្រ៖

$.ajax(); // សំណើ GET នឹងត្រូវបានផ្ញើទៅកាន់ម៉ាស៊ីនមេទៅកាន់ URL នៃទំព័របច្ចុប្បន្នដោយមិនបញ្ជាក់ប៉ារ៉ាម៉ែត្រណាមួយឡើយ។

ប្រសិនបើអ្នកត្រូវការផ្ទុក និងប្រតិបត្តិឯកសារ js អ្នកអាចធ្វើវាដូចនេះ៖

$.ajax ((ប្រភេទ៖ "GET", url: "test.js", dataType: "script" ) );

ចូរធ្វើការស្នើសុំ POST ទៅកាន់ម៉ាស៊ីនមេ ដោយបញ្ជាក់ប៉ារ៉ាម៉ែត្រពីរ និងជូនដំណឹងដល់អ្នកប្រើប្រាស់អំពីសំណើដែលបានបញ្ចប់ដោយជោគជ័យ៖

$.ajax (( ប្រភេទ៖ "POST", url: "some.php", ទិន្នន័យ៖ "name=John&location=Boston", ជោគជ័យ៖ មុខងារ (msg) ( alert ( "ទិន្នន័យបានមកដល់៖ " + msg ); ) ) ;

តោះធ្វើបច្ចុប្បន្នភាពមាតិកានៃទំព័រ html ដែលចង់បាន៖

$.ajax (( url: "test.html", ឃ្លាំងសម្ងាត់៖ មិនពិត, ជោគជ័យ៖ មុខងារ (html) ( $("#results" ).append (html); ) );

តោះធ្វើសំណើសមកាលកម្មទៅម៉ាស៊ីនមេ។ ខណៈពេលដែលសំណើកំពុងត្រូវបានប្រតិបត្តិ ទំព័រនឹងមិនឆ្លើយតបចំពោះសកម្មភាពរបស់អ្នកប្រើទេ៖

// សរសេរទិន្នន័យដែលបានផ្ញើពីម៉ាស៊ីនមេទៅអថេរ html var html = $.ajax (( url: "some.php" , async: false ) .responseText ;

ជាប៉ារ៉ាម៉ែត្រ យើងនឹងផ្ញើវត្ថុ xml ទៅម៉ាស៊ីនមេ។ ដើម្បីបញ្ជូនវាឱ្យបានត្រឹមត្រូវ អ្នកត្រូវតែលុបចោលការបំប្លែងបឋមនៃប៉ារ៉ាម៉ែត្រ (processData:false)។ យើង​នឹង​បញ្ជាក់​មុខងារ​ផ្ទាល់​ខ្លួន handleResponse ជា​អ្នក​ដោះស្រាយ​សម្រាប់​ការ​បំពេញ​សំណើ​ដោយ​ជោគជ័យ៖

var xmlDocument = [បង្កើតឯកសារ xml] ; $.ajax (( url: "page.php", processData: false, data: xmlDocument, success: handleResponse ) );

វិធីសាស្រ្តកម្រិតខ្ពស់

ចាប់ផ្តើមជាមួយ jQuery-1.5 មានទិសដៅថ្មីចំនួនបីដែលអនុញ្ញាតឱ្យអ្នកប្រើ $.ajax() កាន់តែស៊ីជម្រៅ។ ទីមួយនៃពួកគេ (Prefilters) អនុញ្ញាតឱ្យអ្នកអនុវត្តឧបាយកលបន្ថែមភ្លាមៗមុនពេលផ្ញើសំណើ។ ជាមួយនឹងវិធីសាស្រ្តទីពីរ (កម្មវិធីបម្លែង) អ្នកអាចប្រាប់ jQuery ពីរបៀបបំប្លែងទិន្នន័យដែលទទួលបានពីម៉ាស៊ីនមេប្រសិនបើវាមិនត្រូវគ្នានឹងទម្រង់ដែលរំពឹងទុក។ វិធីសាស្រ្តទីបី (ការដឹកជញ្ជូន) គឺជាកម្រិតទាបបំផុត វាអនុញ្ញាតឱ្យអ្នករៀបចំសំណើទៅម៉ាស៊ីនមេដោយឯករាជ្យ។

តម្រងមុន។

វិធីសាស្រ្តនេះរួមមានការដំឡើងឧបករណ៍ដោះស្រាយដែលត្រូវបានហៅមុនពេលសំណើ ajax នីមួយៗត្រូវបានធ្វើឡើង។ ឧបករណ៍ដោះស្រាយនេះនាំមុខការប្រតិបត្តិរបស់អ្នកដោះស្រាយ ajax ផ្សេងទៀត។ វាត្រូវបានដំឡើងដោយប្រើមុខងារ $.ajaxPrefilter()៖

$.ajaxPrefilter (មុខងារ (ជម្រើស, ជម្រើសដើម, jqXHR) ( ) );

កន្លែងណា
ជម្រើស- ការកំណត់នៃសំណើបច្ចុប្បន្ន,
ជម្រើសដើម- កំណត់​លំនាំដើម,
jqXHR- jqXHR វត្ថុនៃសំណើនេះ។

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

var currentRequests = ( ); $.ajaxPrefilter (function (options, originalOptions, jqXHR) ( if (options.abortOnRetry) ( if (currentRequests[ options.url ]) ( currentRequests[ options.url ] .abort (); ) currentRequests[ options.url ] = jqXHR ;) );

វាងាយស្រួលក្នុងការដំណើរការការកំណត់ដែលមានស្រាប់នៅក្នុង ajaxPrefilter។ ឧទាហរណ៍ នេះជារបៀបដែលអ្នកអាចផ្លាស់ប្តូរសំណើឆ្លងដែនទៅមួយដែលបានប្តូរទិសតាមរយៈម៉ាស៊ីនមេដែនរបស់អ្នក៖

$.ajaxPrefilter (មុខងារ (ជម្រើស) (ប្រសិនបើ (options.crossDomain) ( options.url = "http://mydomain.net/proxy/" + encodeURIComponent( options.url ); options.crossDomain = មិនពិត ; );

លើសពីនេះទៀត អ្នកអាចបញ្ជាក់តម្លៃ dataType ដែល prefilter នឹងដំណើរការ។ ដូច្នេះ ជាឧទាហរណ៍ អ្នកអាចបញ្ជាក់ប្រភេទ json និង script៖

$.ajaxPrefilter ( "json script" មុខងារ (ជម្រើស ជម្រើសដើម jqXHR) ( // ផ្លាស់ប្តូរជម្រើស ពិនិត្យជម្រើសដើម និងវត្ថុ jqXHR) );

ជាចុងក្រោយ អ្នកអាចផ្លាស់ប្តូរតម្លៃ dataType ដើម្បីត្រឡប់តម្លៃដែលចង់បាន៖

$.ajaxPrefilter (មុខងារ (ជម្រើស) ( // ផ្លាស់ប្តូរប្រភេទទិន្នន័យទៅជាស្គ្រីប ប្រសិនបើ url បំពេញលក្ខខណ្ឌជាក់លាក់ ប្រសិនបើ (isActuallyScript(options.url)) (ត្រឡប់ "ស្គ្រីប" ; ) );

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

កម្មវិធីបម្លែង

គោលការណ៍នេះរួមមានការដំឡើងឧបករណ៍ដោះស្រាយដែលនឹងដំណើរការប្រសិនបើ dataType ដែលបានបញ្ជាក់នៅក្នុងការកំណត់មិនត្រូវគ្នានឹងប្រភេទទិន្នន័យដែលបានផ្ញើដោយម៉ាស៊ីនមេ។

កម្មវិធីបម្លែងគឺជាការកំណត់ ajax ដូច្នេះអាចត្រូវបានកំណត់ជាសកល៖

// វិធីនេះអ្នកអាចកំណត់ឧបករណ៍ដោះស្រាយដែលនឹងដំណើរការប្រសិនបើ ជំនួសឱ្យ // ប្រភេទ mydatatype ដែលអ្នកបានបញ្ជាក់នៅក្នុង dataType ទិន្នន័យនៃអត្ថបទប្រភេទត្រូវបានទទួល $.ajaxSetup (( converters: ( "text mydatatype" : function ( textValue )( if (valid( textValue ) ) ( // processing the transmitted text return mydatatypeValue; ) else ( // ប្រសិនបើទិន្នន័យដែលបានផ្ញើដោយម៉ាស៊ីនមេមិនត្រូវគ្នានឹងអ្វីដែលរំពឹងទុក // អ្នកអាចបោះការលើកលែងមួយ។ throw exceptionObject; )) ) );

កម្មវិធីបម្លែងនឹងជួយអ្នកនៅពេលណែនាំប្រភេទទិន្នន័យផ្ទាល់ខ្លួន (ផ្ទាល់ខ្លួន) របស់អ្នក។ វាជាការសំខាន់ក្នុងការកត់សម្គាល់ថាមានតែអក្សរតូចប៉ុណ្ណោះគួរតែត្រូវបានប្រើជាឈ្មោះនៃប្រភេទទិន្នន័យបែបនេះ! សំណើសម្រាប់ប្រភេទទិន្នន័យ "mydatatype" ដែលបានរៀបរាប់ខាងលើអាចមើលទៅដូចនេះ៖

$.ajax (url, (ប្រភេទទិន្នន័យ៖ "mydatatype" ) );

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

ដើម្បីអនុវត្តបច្ចេកវិទ្យា សូមប្រើវិធីសាស្ត្រ $.ajax ឬ jQuery.ajax៖

$.ajax(properties) ឬ $.ajax(url [, properties])

ប៉ារ៉ាម៉ែត្រទីពីរត្រូវបានបន្ថែមនៅក្នុងកំណែ 1.5 នៃ jQuery ។

url - អាសយដ្ឋាននៃទំព័រដែលបានស្នើសុំ;

លក្ខណៈសម្បត្តិ - ស្នើសុំលក្ខណៈសម្បត្តិ។

សម្រាប់បញ្ជីជម្រើសពេញលេញ សូមមើលឯកសារ jQuery ។

នៅក្នុងមេរៀននេះ យើងប្រើប៉ារ៉ាម៉ែត្រជាច្រើនដែលប្រើជាទូទៅបំផុត។

ជោគជ័យ (មុខងារ) - មុខងារនេះត្រូវបានហៅបន្ទាប់ពីសំណើបានបញ្ចប់ដោយជោគជ័យ។ មុខងារទទួលបានពី 1 ទៅ 3 ប៉ារ៉ាម៉ែត្រ (អាស្រ័យលើកំណែបណ្ណាល័យដែលបានប្រើ) ។ ប៉ុន្តែប៉ារ៉ាម៉ែត្រទីមួយតែងតែផ្ទុកទិន្នន័យដែលបានត្រឡប់ពីម៉ាស៊ីនមេ។

ទិន្នន័យ (វត្ថុ / ខ្សែអក្សរ) - ទិន្នន័យអ្នកប្រើប្រាស់ដែលត្រូវបានបញ្ជូនទៅទំព័រដែលបានស្នើសុំ។

ប្រភេទទិន្នន័យ (ខ្សែអក្សរ) - តម្លៃដែលអាចធ្វើបាន៖ xml, json, script ឬ html ។ ការពិពណ៌នាអំពីប្រភេទនៃទិន្នន័យដែលរំពឹងទុកនៅក្នុងការឆ្លើយតបរបស់ម៉ាស៊ីនមេ។

ប្រភេទ (ខ្សែអក្សរ) - ប្រភេទសំណើ។ តម្លៃដែលអាចធ្វើបាន៖ GET ឬ POST។ លំនាំដើម៖ ទទួល។

url (ខ្សែអក្សរ) - URL សម្រាប់សំណើ។

ឧទាហរណ៍ ១

ការផ្ទេរអត្ថបទងាយស្រួល។

$.ajax(( url: "response.php?action=sample1", ជោគជ័យ៖ មុខងារ(ទិន្នន័យ)( $(.results").html(data); ) ));

មានធាតុ .result div សម្រាប់ការឆ្លើយតប។

រង់ចាំចម្លើយ

ម៉ាស៊ីនមេគ្រាន់តែត្រឡប់ខ្សែអក្សរ៖

អេកូ "ឧទាហរណ៍ 1 - ការផ្ទេរបានបញ្ចប់ដោយជោគជ័យ";

ឧទាហរណ៍ ២

យើងបញ្ជូនទិន្នន័យអ្នកប្រើប្រាស់ទៅស្គ្រីប PHP ។

$.ajax(( type: "POST", url: "response.php?action=sample2", data: "name=Andrew&nickname=Aramis", ជោគជ័យ៖ function(data)($(.results").html( ទិន្នន័យ); ) ));

ម៉ាស៊ីនមេត្រឡប់ខ្សែអក្សរជាមួយនឹងទិន្នន័យបញ្ជូនដែលបានបញ្ចូលទៅក្នុងវា៖

Echo "ឧទាហរណ៍ 2 - ការផ្ទេរបានបញ្ចប់ដោយជោគជ័យ។ ប៉ារ៉ាម៉ែត្រ៖ name = " . $_POST["ឈ្មោះ"] ។ ", សម្មតិនាម = " ។ $_POST["ឈ្មោះហៅក្រៅ"];

ឧទាហរណ៍ ៣

ឆ្លងកាត់ និងប្រតិបត្តិកូដ JavaScript

$.ajax((ប្រភេទទិន្នន័យ៖ "ស្គ្រីប", url: "response.php?action=sample3", ))

ម៉ាស៊ីនមេប្រតិបត្តិកូដ៖

Echo "$(.results").html("ឧទាហរណ៍ 3 - ការប្រតិបត្តិ JavaScript");";

ឧទាហរណ៍ 4

យើងប្រើ XML ។ ឧទាហរណ៍អាចត្រូវបានប្រើដើម្បីធ្វើការជាមួយ XML ខាងក្រៅឧទាហរណ៍ RSS feed ។

$.ajax(( dataType: "xml", url: "response.php?action=sample4", ជោគជ័យ: function(xmldata)( $(."results").html(""); $(xmldata).ស្វែងរក ("ធាតុ").each(function())($("").html($(this).text()).appendTo(.results"); )); ) ));

ម៉ាស៊ីនមេគួរតែត្រឡប់លេខកូដ XML៖

បឋមកថា("ប្រភេទមាតិកា៖ កម្មវិធី/xml; សំណុំតួអក្សរ = UTF-8"); អេកូ