ធ្វើសំណើទៅម៉ាស៊ីនមេដោយមិនផ្ទុកទំព័រឡើងវិញ។ នេះគឺជាវិធីសាស្ត្រកម្រិតទាបដែលមានការកំណត់ជាច្រើន។ វាបញ្ជាក់ពីប្រតិបត្តិការនៃវិធីសាស្រ្ត 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 ត្រូវតែតំណាងដោយម៉ាស៊ីនមេជាអត្ថបទ/xml ឬកម្មវិធី/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។

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

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

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

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

ភាគច្រើន ជម្រើសសាមញ្ញការប្រើប្រាស់នឹងហៅ $.ajax() ដោយមិនបញ្ជាក់ប៉ារ៉ាម៉ែត្រ៖

$.ajax(); // សំណើ GET ទៅកាន់អាសយដ្ឋាន url នឹងត្រូវបានផ្ញើទៅកាន់ម៉ាស៊ីនមេទំព័របច្ចុប្បន្ន

និងដោយមិនបញ្ជាក់ប៉ារ៉ាម៉ែត្រណាមួយឡើយ។

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

ចូរធ្វើការស្នើសុំ 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)។ ក្នុងនាមជាអ្នកដោះស្រាយសម្រាប់ការបញ្ចប់សំណើដោយជោគជ័យ យើងបញ្ជាក់ មុខងារផ្ទាល់ខ្លួនចំណុចទាញ៖

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ការកំណត់ផ្ទាល់ខ្លួន (ឧ. ការកំណត់ថ្មីមិនស្គាល់បណ្ណាល័យដែលបានបញ្ជាក់ក្នុងសំណើ)។ ឧទាហរណ៍អ្នកអាចចូលបាន។ការរៀបចំផ្ទាល់ខ្លួន

var currentRequests = ( );

$.ajaxPrefilter (មុខងារ (ជម្រើស, originalOptions, jqXHR) (ប្រសិនបើ (options.abortOnRetry) (ប្រសិនបើ (currentRequests[ options.url]) (CurrentRequests[ options.url] .abort (); ) currentRequests[ options.url ] = jqXHR ;)); វាងាយស្រួលក្នុងការដំណើរការនិងការកំណត់ដែលមានស្រាប់

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

$.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 និង jQuery គឺហើយនឹងមើលឧទាហរណ៍អំពីរបៀបប្រើវា។

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

jQuery - JavaScript-framework ដែលជាបណ្ណាល័យដែលអនុញ្ញាតឱ្យអ្នកកាន់តែងាយស្រួលប្រើមុខងារ Javascript មួយចំនួនដូចជា៖ ការបង្កើត ផលប៉ះពាល់ដែលមើលឃើញការគ្រប់គ្រងព្រឹត្តិការណ៍ ធ្វើការជាមួយ DOM និង AJAX គាំទ្រ។

អ្នកអាចទាញយកកំណែចុងក្រោយបំផុតរបស់ jQuery ហើយស្គាល់លក្ខណៈពិសេសទាំងអស់ដោយលម្អិតនៅលើគេហទំព័ររបស់អ្នកអភិវឌ្ឍន៍៖ http://www.jquery.com/

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

សូមបន្តដើម្បីពិចារណាឧទាហរណ៍។

សំខាន់!
ដើម្បីឱ្យឧទាហរណ៍ដំណើរការបានត្រឹមត្រូវ អ្នកត្រូវតែ៖
1. ឯកសារទាំងអស់ត្រូវតែសរសេរនៅក្នុងការអ៊ិនកូដ UTF-8 ។
2. ស្គ្រីបត្រូវតែត្រូវបានប្រតិបត្តិនៅលើម៉ាស៊ីនមេបណ្តាញ ហើយមិនដំណើរការនៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិតជាឯកសារនោះទេ។

ឧទាហរណ៍ទី 1៖ ការធ្វើបច្ចុប្បន្នភាពខ្លឹមសារថាមវន្តដោយប្រើកម្មវិធីកំណត់ម៉ោង

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

ខ្លឹមសារនៃឯកសារ index.html ។

function show()( $.ajax(( url: "time.php", cache: false, success: function(html)( $("#content").html(html); ))); ) $(document .រួចរាល់(មុខងារ())(បង្ហាញ(); setInterval("show()",1000); ));

កូដមានមុខងារជាច្រើន អនុញ្ញាតឱ្យយើងពន្យល់ពួកគេ។

1. បណ្ណាល័យ jQuery ត្រូវបានរួមបញ្ចូលនៅក្នុងបឋមកថា ឯកសារ HTMLនេះជាអ្វីដែលបន្ទាត់នេះត្រូវបានសរសេរសម្រាប់។

ឯកសារ jquery.js ខ្លួនវាមានទីតាំងនៅក្នុងថតដូចគ្នានឹងឯកសារឧទាហរណ៍។

2. ធុងមួយត្រូវបានបង្កើតឡើងនៅក្នុងតួនៃឯកសារដែលយើងនឹងផ្ទុកមាតិកា។

3. ចម្លែកមួយ នៅ glance ដំបូង មុខងារ $(document).ready() ត្រូវបានទាមទារសម្រាប់ ប្រតិបត្តិការត្រឹមត្រូវ។ jQuery ក្រៅ​ពី​នេះ​នៅ​ក្នុង​វា​យើង​អាច​អនុវត្ត​ការ​ត្រៀម​ខ្លួន​ទាំង​អស់​សម្រាប់​កម្មវិធី​ដំណើរការ។ ក្នុងករណីរបស់យើង យើងហៅមុខងារ show() ដែលបញ្ជាក់ពីយន្តការសម្រាប់ការទាញយកមាតិកាពីឯកសារផ្សេងទៀត ហើយកំណត់កម្មវិធីកំណត់ម៉ោង ដូច្នេះមុខងារ show() ត្រូវបានហៅម្តងក្នុងមួយវិនាទី។

$(document).ready(function())(show(); setInterval("show()",1000); ));

4. មុខងារ show() រួមមានការហៅមុខងារ $.ajax() ជាមួយនឹងចំនួនប៉ារ៉ាម៉ែត្រជាក់លាក់ ដែលអនុញ្ញាតឱ្យយើងទទួលបានព័ត៌មានពីឯកសារខាងក្រៅនៅលើ server ក្នុងផ្ទៃខាងក្រោយ។

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

សូមក្រឡេកមើលប៉ារ៉ាម៉ែត្រដែលប្រើដោយមុខងារ $.ajax()។

Url: "time.php" ចូលប្រើឯកសារ time.php ដើម្បីទាញយកមាតិកា។
ឃ្លាំងសម្ងាត់៖ លទ្ធផលសំណួរមិនពិតមិនត្រូវបានទុកក្នុងឃ្លាំងសម្ងាត់ទេ។

Success: function(html)( $("#content").html(html); ) ប្រសិនបើសំណើរបានជោគជ័យ ការគ្រប់គ្រងឆ្លងកាត់ទៅមុខងារ ដែលទទួលមាតិកាជាប៉ារ៉ាម៉ែត្រ និងសរសេរកុងតឺន័ររបស់វា។ ការសរសេរទៅកាន់កុងតឺន័រកើតឡើងនៅក្នុងបន្ទាត់នេះ៖

$("#content").html(html);

ខ្លឹមសារនៃឯកសារ time.php ។

គោលបំណងនៃឯកសារ time.php គឺដើម្បីបង្ហាញពេលវេលាបច្ចុប្បន្ននៅលើអេក្រង់។

ទាញយកឯកសារប្រភពឧទាហរណ៍ (16.6 kb)៖

ខ្លឹមសារនៃឯកសារ index.html ។

ឧទាហរណ៍ទី 2៖ ការធ្វើបច្ចុប្បន្នភាពមាតិកាដោយថាមវន្តដោយផ្អែកលើការជ្រើសរើសអ្នកប្រើប្រាស់

កម្មវិធីដែលផ្ទុកមាតិកាដោយថាមវន្តតាមការសំរេចចិត្តរបស់អ្នកប្រើ។

តើអ្នកចង់បើកទំព័រមួយណា?

$(document).ready(function())($("#btn1").click(function())($.ajax(( url: "page1.html", cache: false, success: function(html) ($("#content").html(html); )); $("#btn2").click(function())($.ajax(( url: "page2.html", cache: false, success : function(html)( $("#content").html(html); ) ));

នៅក្នុងតួឯកសារ ទម្រង់មួយត្រូវបានបង្កើតឡើងដែលមានប៊ូតុងពីរដែលអ្នកប្រើប្រាស់ជ្រើសរើសមាតិកាដែលចង់បាន។ និងធុងសម្រាប់ផ្ទុកមាតិកា។ ព្រឹត្តិការណ៍ចុចនៅលើប៊ូតុង "ទំព័រ 1" ត្រូវបានគ្រប់គ្រងដោយមុខងារ $("#btn1").click() ហើយព្រឹត្តិការណ៍ចុចនៅលើប៊ូតុង "ទំព័រ 2" ត្រូវបានដំណើរការដោយ $("#btn2") ។ មុខងារចុច () ។មាតិកានៃឯកសារ page1.html និង page2.html ដែលត្រូវបានផ្ទុកដោយថាមវន្តទៅក្នុងផ្ទៃមាតិកា គឺជាទំព័រ HTML សាមញ្ញ ឬ

ឯកសារអត្ថបទ

ជាមួយនឹងមាតិកា។

ទាញយកឯកសារប្រភពឧទាហរណ៍ (18.4 kb)៖

ខ្លឹមសារនៃឯកសារ index.html ។

ឧទាហរណ៍ទី 3៖ ការផ្ញើទិន្នន័យទៅកាន់ម៉ាស៊ីនមេក្នុងផ្ទៃខាងក្រោយ និងការទទួលមាតិកា


សូមក្រឡេកមើលឧទាហរណ៍ដែលផ្ញើឈ្មោះអ្នកប្រើប្រាស់ដែលបានបញ្ចូលទៅម៉ាស៊ីនមេ។ នៅពេលដែលម៉ាស៊ីនមេទទួលបានឈ្មោះ វាចេញការស្វាគមន៍ និងរាប់ចំនួនតួអក្សរនៅក្នុងឈ្មោះដែលបានបញ្ចូល។

ទម្រង់សម្រាប់បញ្ចូលឈ្មោះអ្នកប្រើប្រាស់ត្រូវបានបង្កើតនៅក្នុងតួឯកសារ។ និងធុងសម្រាប់ផ្ទុកមាតិកាថាមវន្ត។

ចំណាំថាទម្រង់ខ្លួនវាមិនមានវាលសកម្មភាព និងវិធីសាស្ត្រធម្មតាទេ។ មុខងារ $("#myForm").submit() ដើរតួជាអ្នកដោះស្រាយសម្រាប់ព្រឹត្តិការណ៍នៃការចុចលើប៊ូតុង "Submit" ។ តោះមើលមុខងារនេះ។

$("#myForm").submit(function())( $.ajax(( type: "POST", url: "greetings.php", data: "username="+$("#username").val ( ), ជោគជ័យ៖ function(html)( $("#content").html(html); ) ));

ដូចដែលយើងអាចមើលឃើញ ការងារសំខាន់គឺទាក់ទងជាមួយមុខងារ $.ajax() ម្តងទៀត។ លើកនេះ ប៉ារ៉ាម៉ែត្របន្ថែមលេចឡើងដែលមិនត្រូវបានពិចារណាក្នុងឧទាហរណ៍ទី 1 និងទី 2។ ពោលគឺ៖

ប្រភេទ៖ "POST" ប្រភេទផ្ទេរទិន្នន័យ។ ទិន្នន័យ៖ "username="+$("#username").val() ប៉ារ៉ាម៉ែត្របានបញ្ជូនទៅម៉ាស៊ីនមេ។ INក្នុងករណីនេះ
យើងឆ្លងកាត់មាតិកានៃវាលឈ្មោះអ្នកប្រើ - ឈ្មោះអ្នកប្រើ។ ជាទូទៅ ប៉ារ៉ាម៉ែត្រត្រូវបានសរសេរតាមរបៀបដូចគ្នានឹងវិធីសាស្ត្រ GET ក្នុងបន្ទាត់មួយ ឧទាហរណ៍៖

ទិន្នន័យ៖ "username=Vasya&age=18&sex=male"

សូមចំណាំថានៅចុងបញ្ចប់មានបន្ទាត់មួយ:

ត្រឡប់មិនពិត; វាត្រូវបានធ្វើដូច្នេះថាទម្រង់មិនព្យាយាមផ្ទេរទិន្នន័យទៅឯកសារដែលវាត្រូវបានបើកដំណើរការ ហើយទំព័រមិនផ្ទុកឡើងវិញទេ។

ខ្លឹមសារនៃឯកសារ greetings.php ។

យើងបង្ហាញការស្វាគមន៍ និងរាប់ចំនួនតួអក្សរនៅក្នុងឈ្មោះ។

ទាញយកឯកសារប្រភពឧទាហរណ៍ (16.8 kb)៖

វាគឺមានតំលៃនិយាយនៅក្នុងការសន្និដ្ឋានថាបន្ថែមពីលើគុណសម្បត្តិជាក់ស្តែងនៃការបង្កើតទំព័រដោយប្រើមាតិកាធ្វើឱ្យទាន់សម័យថាមវន្តមានគុណវិបត្តិមួយចំនួនដែលគួរត្រូវយកមកពិចារណានៅពេលបង្កើតគេហទំព័រគឺ:

1. នៅលើទំព័រដែលមានការធ្វើបច្ចុប្បន្នភាពមាតិកាថាមវន្ត ប៊ូតុង "ថយក្រោយ" នៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិតមិនដំណើរការត្រឹមត្រូវ។

2. ទំព័រដែលមានការអាប់ដេតមាតិកាថាមវន្តមិនផ្លាស់ប្តូរ URLs ដោយផ្អែកលើមាតិការបស់ពួកគេ ដូច្នេះពួកគេមិនអាចចំណាំបានទេ។ 3. ទំព័រដែលមានការធ្វើបច្ចុប្បន្នភាពមាតិកាថាមវន្តមិនត្រូវបានធ្វើលិបិក្រមទេ។ម៉ាស៊ីនស្វែងរក

, ដោយសារតែ ពួកគេមិនប្រតិបត្តិពាក្យបញ្ជា JavaScript ទេ។ អ្នកអាចកម្ចាត់គុណវិបត្តិខាងលើតាមកម្មវិធី

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

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

ចូរយើងបង្កើតកិច្ចការតូចមួយសម្រាប់ខ្លួនយើង ហើយពិនិត្យមើលភាពអាចរកបាន អាសយដ្ឋានអ៊ីមែលនៅក្នុងមូលដ្ឋានទិន្នន័យដោយមិនផ្ទុកទំព័រឡើងវិញដោយប្រើ php និង ajax ។ ឧទាហរណ៍នេះនឹងបង្ហាញយ៉ាងច្បាស់ពីរបៀបដែលយើងអាចធ្វើអន្តរកម្មជាមួយម៉ាស៊ីនមេដោយមិនចាំបាច់ផ្ទុកទំព័រឡើងវិញនៅក្នុងកម្មវិធីរុករក ហើយវាត្រូវបានគេប្រើជាញឹកញាប់សម្រាប់ប្រភេទផ្សេងៗនៃសុពលភាពទម្រង់អ្នកប្រើប្រាស់។ នៅក្នុងថត root យើងនឹងបង្កើតឯកសារចំនួន 3 ដែលមានឈ្មោះថា index.php, email.php, validate.js ។

ការបង្កើតទំព័រ

តោះបង្កើត ទំព័រសាមញ្ញជា​មួយ​នឹង​ទម្រង់​មួយ​ដែល​មាន​វាល​មួយ​សម្រាប់​បញ្ចូល​អ៊ីមែល។
វាក្យសម្ព័ន្ធឯកសារ index.php

ការបង្រៀន AJAX

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

ការបង្កើតអក្សរ js

វាក្យសម្ព័ន្ធនៃឯកសារ validate.js

$(document).ready(function())(var email = ""; $("#email").keyup(function())(var value = $(this).val(); $.ajax(( ប្រភេទ៖ "POST", url:"email.php", data:"email="+value, success:function(msg)( if(msg == "valid")($("#message").html( "អ៊ីមែលនេះអាចប្រើបាន។ អ៊ីមែលនេះត្រូវបានយករួចហើយ។"); ) ) ) )); "សូមដាក់ទិន្នន័យទៅកាន់អ៊ីមែលទាំងអស់"); )else( $.ajax(( type: "POST", url:"email.php", data:"add_email="+email, success:function(msg)($ ("#សារ" .html(msg);

កម្មវិធីគ្រប់គ្រង PHP

ស្គ្រីបនេះនឹងទទួលបានសំណើ POST ពីអតិថិជន ដំណើរការវា និងត្រឡប់លទ្ធផល។ AJAX អានលទ្ធផល និងធ្វើការសម្រេចចិត្តដោយផ្អែកលើវា។
វាក្យសម្ព័ន្ធឯកសារ Email.php

$connection = mysqli_connect("localhost","email","email","email"); if(isset($_POST["email"]) && $_POST["email"] != "")( $email = $_POST["email"]; $email = mysqli_real_escape_string($connection,$email); ប្រសិនបើ (!filter_var($email, FILTER_VALIDATE_EMAIL))( echo "invalid"; )else($sql = "SELECT id FROM email WHERE email="$email""; $result = mysqli_query($connection,$sql); if( mysqli_num_rows($result) == 1)( echo "invalid"; )else(echo "valid"; ) )) if(isset($_POST["add_email"]) && $_POST["add_email"] !="" )( $email = mysqli_real_escape_string($connection, $_POST["add_email"]); $sql = "បញ្ចូលក្នុងអ៊ីមែល(email) VALUES("$email")"; if(mysqli_query($connection,$sql)))( អេកូជោគជ័យ"; ) else (បន្ទរ "កំហុស"; ))

នៅក្នុងស្គ្រីប php របស់យើង កូដទូទៅបំផុតដែលដំណើរការសំណើប្រកាស និងបោះពុម្ពវានៅលើទំព័រ អត្ថបទជាក់លាក់. ជាលទ្ធផល AJAX ផ្ញើ php សំណើស្គ្រីប ស្គ្រីបដំណើរការវា និងបង្កើតលទ្ធផល AJAX អានលទ្ធផល និងផ្លាស់ប្តូរទំព័រក្នុងពេលវេលាជាក់ស្តែង។

AJAX ផ្ញើសំណើ POST ទៅស្គ្រីបដោយប្រើលេខកូដនេះ៖

$.ajax(( type:"POST", url:"email.php", data:"email="+value, success:function(msg)( if(msg == "valid")( $("#message " .html("អ៊ីមែលនេះអាចប្រើបាន។"); email = value; )else($("#message").html("អ៊ីមែលនេះត្រូវបានយករួចហើយ។"); ) ) ));

ប្រភេទ - ប្រភេទស្នើសុំ POST ឬ GET ។ ក្នុងករណីរបស់យើង POST;
url - អាសយដ្ឋាននៃស្គ្រីបដែលសំណើត្រូវបានផ្ញើ។
ទិន្នន័យ - ទិន្នន័យដែលត្រូវបានបញ្ជូននៅក្នុងការស្នើសុំ;
ជោគជ័យ - អ្វីដែលត្រូវធ្វើជាលទ្ធផលនៃការអនុវត្តសំណើជោគជ័យ។ ក្នុងករណីរបស់យើងមុខងារត្រូវបានគេហៅថា;

នៅក្នុងស្គ្រីបខ្លួនវា វត្តមានរបស់អ៊ីមែលនៅក្នុងមូលដ្ឋានទិន្នន័យត្រូវបានពិនិត្យរាល់ពេលដែលតួអក្សរមួយត្រូវបានបញ្ចូលទៅក្នុងវាលអ៊ីមែល។ នៅក្នុងស្គ្រីប ផ្នែក $("#email").keyup(function()()); ដែលពិនិត្យមើលការចុចគ្រាប់ចុចនៅក្នុងវាលដែលមានលេខសម្គាល់ = "អ៊ីមែល" ។
ដូចដែលអ្នកអាចឃើញ កូដគឺសាមញ្ញណាស់ និងមិនតម្រូវឱ្យមានជំនាញដ៏អស្ចារ្យជាពិសេសដើម្បីយល់ អ្វីគ្រប់យ៉ាងត្រូវបានភ្ជាប់ទៅនឹងដំណើរការព្រឹត្តិការណ៍ keyup() - ការចុចគ្រាប់ចុចចុច () - ការចុចកណ្ដុរលើធាតុមួយ។ នេះត្រូវបានបន្តដោយសំណើ AJAX និងការឆ្លើយតបពីស្គ្រីប។ ដូច្នេះដោយប្រើ php និង ajax អ្នកអាចទទួលបានស្ទើរតែ លទ្ធភាពគ្មានដែនកំណត់ដើម្បីបង្កើតទំព័រអន្តរកម្ម។
កូដនេះមិនធ្វើពុតជាមានគុណភាពខ្ពស់នោះទេ ប៉ុន្តែប្រសិនបើអ្នកបង្កើតវា បន្ថែមសុពលភាពត្រឹមត្រូវនៅកម្រិតម៉ាស៊ីនភ្ញៀវ និងម៉ាស៊ីនមេ ហើយណែនាំ css នោះវាអាចប្រើក្នុងគម្រោងរបស់អ្នក។
ប្រសិនបើអ្នកមានសំណួរណាមួយ សូមកុំស្ទាក់ស្ទើរក្នុងការសរសេរមតិយោបល់។
ខ្ញុំសូមជូនពរអ្នក។ សូមអោយមានថ្ងៃល្អ។ហើយជួបគ្នាឆាប់ៗនេះ :)

សំណុំនៃគូគន្លឹះ/តម្លៃដែលកំណត់រចនាសម្ព័ន្ធសំណើ AJAX. ប៉ារ៉ាម៉ែត្រទាំងអស់គឺស្រេចចិត្ត។ វាអាចទទួលយកបាន ប៉ុន្តែមិនត្រូវបានណែនាំទេ ដើម្បីកំណត់តម្លៃលំនាំដើមសម្រាប់ប៉ារ៉ាម៉ែត្រណាមួយដោយប្រើវិធីសាស្ត្រ $.ajaxSetup()។
វិធីសាស្ត្រ $.ajax() គាំទ្រប៉ារ៉ាម៉ែត្រខាងក្រោម៖

ទទួលយក (លំនាំដើម៖ អាស្រ័យលើប្រភេទទិន្នន័យ)។

ប្រភេទ៖ PlainObject។
សំណុំនៃគូសោ/តម្លៃដែលត្រូវបានផ្ញើទៅ ទទួលយកក្បាលសំណើ។ បឋមកថានេះប្រាប់ម៉ាស៊ីនមេអំពីប្រភេទនៃការឆ្លើយតបដែលសំណើនឹងទទួលយកក្នុងការឆ្លើយតប។ ចំណាំថាតម្លៃនៃប៉ារ៉ាម៉ែត្រដែលបានបញ្ជាក់នៅក្នុង dataType (ប្រភេទនៃទិន្នន័យដែលយើងរំពឹងពីម៉ាស៊ីនមេ) ត្រូវបានផ្គូផ្គងទៅនឹងអ្វីដែលបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រ។ លើសពីនេះទៀត ដើម្បីដំណើរការការឆ្លើយតបពីម៉ាស៊ីនមេបានត្រឹមត្រូវ អ្នកត្រូវតែបញ្ជាក់មុខងារមួយនៅក្នុងប៉ារ៉ាម៉ែត្រកម្មវិធីបម្លែងដែលត្រឡប់តម្លៃឆ្លើយតបដែលបានបំប្លែង។ ឧទាហរណ៍៖ $.ajax(( ទទួលយក : ( mycustomtype : "application/x-some-custom-type " ) // បញ្ជាក់ពីរបៀបដំណើរការកម្មវិធីបំប្លែងឆ្លើយតប : ( "text mycustomtype": function ( លទ្ធផល) ( // ត្រឡប់តម្លៃឆ្លើយតបដែលបានបំលែង ត្រឡប់លទ្ធផលថ្មី; ) ) // ប្រភេទទិន្នន័យរំពឹងទុក ("mycustomtype") dataType : "mycustomtype") );

async (លំនាំដើម៖ ពិត) ។

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

មុនពេលផ្ញើ។ ប្រភេទ៖ មុខងារ(jqXHR jqXHR , PlainObject).
ការកំណត់ មុខងារហៅត្រឡប់មកវិញដែលនឹងត្រូវបានហៅមុនពេលសំណើ AJAX ត្រូវបានធ្វើឡើង។ មុខងារអនុញ្ញាតឱ្យអ្នកផ្លាស់ប្តូរវត្ថុ jqXHR (ក្នុង jQuery 1.4.x វត្ថុ XMLHTTPRequest) មុនពេលវាត្រូវបានផ្ញើ។ វត្ថុ jqXHR គឺជាកម្មវិធីបន្ថែមដែលពង្រីកវត្ថុ XMLHttpRequest វត្ថុមានលក្ខណៈសម្បត្តិ និងវិធីសាស្ត្រជាច្រើនដែលអនុញ្ញាតឱ្យអ្នកទទួលបានច្រើនព័ត៌មានពេញលេញ អំពីការឆ្លើយតបរបស់ម៉ាស៊ីនមេ ហើយវត្ថុក៏មានវិធីសាស្ត្រសន្យាផងដែរ។ ប្រសិនបើអនុគមន៍ beforeSend ត្រឡប់មិនពិត នោះសំណើ AJAX នឹងត្រូវបានលុបចោល។ ចាប់តាំងពីកំណែ jQuery 1.5

មុខងារ beforeSend នឹងត្រូវបានហៅដោយមិនគិតពីប្រភេទសំណើ។ ឃ្លាំងសម្ងាត់ (លំនាំដើម៖ ពិត សម្រាប់ប្រភេទទិន្នន័យ"ស្គ្រីប" "jsonp"និង

មិនពិត)។
ប្រភេទ៖ ប៊ូលីន។ ប្រសិនបើកំណត់ទៅមិនពិត វានឹងធ្វើឱ្យទំព័រដែលបានស្នើសុំមិនត្រូវបានទុកក្នុងឃ្លាំងសម្ងាត់ដោយកម្មវិធីរុករក។ ចំណាំថាមិនពិតនឹងដំណើរការបានត្រឹមត្រូវជាមួយ"ស្គ្រីប" ក្បាលទទួលបាន

សំណើ។

ប្រភេទ៖ មុខងារ(jqXHR ប្រភេទ៖ មុខងារ(jqXHR, ខ្សែអក្សរ ស្ថានភាពអត្ថបទ).
អនុគមន៍​ដែល​ត្រូវ​បាន​ហៅ​នៅ​ពេល​សំណើ​បញ្ចប់ (មុខងារ​ត្រូវ​បាន​ប្រតិបត្តិ​បន្ទាប់​ពី​ព្រឹត្តិការណ៍ AJAX "ជោគជ័យ"ឬ "កំហុស") ប៉ារ៉ាម៉ែត្រពីរត្រូវបានបញ្ជូនទៅមុខងារ៖ ប្រភេទ៖ មុខងារ(jqXHR(ក្នុង jQuery 1.4.x object សំណើ XMLHTTPR) និងបន្ទាត់ដែលត្រូវនឹងស្ថានភាពសំណើ ( "ជោគជ័យ", "បាន​កែប្រែ", "គ្មានខ្លឹមសារ", "កំហុស", "អស់ពេល", "ការរំលូតកូន", ឬ "parsereror") ចាប់តាំងពី jQuery 1.5 ប៉ារ៉ាម៉ែត្រពេញលេញអាចទទួលយកអារេនៃមុខងារដែលនឹងត្រូវបានគេហៅថាម្តងមួយៗ។

មាតិកា។

ប្រភេទ៖ PlainObject។
វត្ថុដែលមានគូ string/regex ដែលកំណត់ពីរបៀបដែល jQuery នឹងដំណើរការ (ញែក) ការឆ្លើយតបអាស្រ័យលើប្រភេទមាតិកា។ បានបន្ថែមនៅក្នុង jQuery 1.5 ។

ប្រភេទមាតិកា (លំនាំដើម៖ "application/x-www-form-urlencoded; charset=UTF-8").

ប្រភេទ៖ ប៊ូលីន ឬខ្សែអក្សរ។
កំណត់ប្រភេទនៃមាតិកាដែលបានបញ្ជាក់នៅក្នុងសំណើនៅពេលផ្ញើទិន្នន័យទៅម៉ាស៊ីនមេ។ ចាប់តាំងពី jQuery 1.6 វាអាចបញ្ជាក់តម្លៃមិនពិត ក្នុងករណីនេះ jQuery មិនឆ្លងកាត់វាលនៅក្នុងបឋមកថា ប្រភេទមាតិកាទាំងអស់។

បរិបទ។

ប្រភេទ៖ PlainObject។
នៅពេលដំណើរការមុខងារ AJAX callback បរិបទប្រតិបត្តិរបស់ពួកគេគឺ វត្ថុបង្អួច. ប៉ារ៉ាម៉ែត្រ​បរិបទ​អនុញ្ញាត​ឱ្យ​អ្នក​កំណត់​រចនាសម្ព័ន្ធ​បរិបទ​ប្រតិបត្តិ​មុខងារ ដូច្នេះ $(នេះ) នឹង​យោង​ទៅ​ធាតុ DOM ឬ​វត្ថុ​ជាក់លាក់។ ឧទាហរណ៍៖ $.ajax(( url : "test.html", context : $(.myClass "), // new function execution context success : function ()( // ប្រសិនបើសំណើរបានជោគជ័យ សូមហៅទៅ function $ (នេះ .html ("អ្វីគ្រប់យ៉ាងគឺល្អ"); // បន្ថែមមាតិកាអត្ថបទទៅធាតុជាមួយ class.myClass ) ) );

ឧបករណ៍បំប្លែង

តម្លៃលំនាំដើម៖
( "* text ": window.String, // ប្រភេទណាមួយនៅក្នុងអត្ថបទ "text html": true, // text in html "text json": jQuery.parseJSON, // text in JSON "text xml": jQuery.parseXML // text in XML) Type: PlainObject.
វត្ថុដែលមានប្រភេទទិន្នន័យដែលត្រូវបំប្លែង និងរបៀបបំប្លែងវា។ តម្លៃ​នៃ​កម្មវិធី​បម្លែង​នីមួយៗ​គឺ​ជា​មុខងារ​ដែល​ត្រឡប់​តម្លៃ​ឆ្លើយតប​ដែល​បាន​បំប្លែង។ បានបន្ថែមនៅក្នុង jQuery 1.5 ។

crossDomain (លំនាំដើម៖ មិនពិតសម្រាប់សំណើក្នុងដែនដូចគ្នា ពិតសម្រាប់សំណើឆ្លងដែន)។

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

ប្រភេទ៖ PlainObject ឬ String ឬ Array ។
ទិន្នន័យដែលនឹងត្រូវបានផ្ញើទៅម៉ាស៊ីនមេ។ ប្រសិន​បើ​ពួកគេ​មិន​មែន​ជា​ខ្សែ​អក្សរ នោះ​ពួកគេ​ត្រូវ​បាន​បំប្លែង​ទៅ​ជា​ខ្សែអក្សរ​សំណួរ។ សម្រាប់ ក្បាលសំណើ ខ្សែអក្សរនឹងត្រូវបានបន្ថែមទៅ URL ។ ដើម្បីទប់ស្កាត់ដំណើរការដោយស្វ័យប្រវត្តិ អ្នកអាចប្រើប៉ារ៉ាម៉ែត្រដំណើរការទិន្នន័យជាមួយនឹងតម្លៃមិនពិត។ ប្រសិនបើទិន្នន័យត្រូវបានផ្ទេរជាផ្នែកនៃវត្ថុមួយ នោះវាត្រូវតែមានគូគន្លឹះ/តម្លៃ។ ប្រសិនបើតម្លៃជាអារេ នោះ jQuery serializes តម្លៃច្រើនជាមួយ key ដូចគ្នា (អាស្រ័យលើតម្លៃនៃ parameter ប្រពៃណី ដែលបើកប្រភេទ serialization ប្រពៃណីដោយផ្អែកលើ $.param method)។

តម្រងទិន្នន័យ។

ប្រភេទ៖ មុខងារ (ខ្សែអក្សរ ទិន្នន័យ, ខ្សែអក្សរ ប្រភេទ) => អ្វីក៏បាន។
មុខងារនេះត្រូវបានហៅបន្ទាប់ពីការបញ្ចប់ដោយជោគជ័យនៃសំណើ AJAX និងអនុញ្ញាតឱ្យអ្នកដំណើរការទិន្នន័យ "ឆៅ" ដែលទទួលបានពីការឆ្លើយតបរបស់ម៉ាស៊ីនមេ។ ការត្រឡប់មកវិញនៃទិន្នន័យត្រូវតែកើតឡើងភ្លាមៗបន្ទាប់ពីដំណើរការ។ មុខងារយកអាគុយម៉ង់ពីរ៖ ទិន្នន័យ- ទិន្នន័យដែលទទួលបានពីម៉ាស៊ីនមេក្នុងទម្រង់ជាខ្សែអក្សរ និង ប្រភេទ- ប្រភេទនៃទិន្នន័យនេះ (តម្លៃនៃប៉ារ៉ាម៉ែត្រ dataType) ។

ប្រភេទទិន្នន័យ (លំនាំដើម៖ xml, ជេសុន, ស្គ្រីប, ឬ html).

ប្រភេទ៖ ខ្សែអក្សរ។
កំណត់ប្រភេទទិន្នន័យដែលអ្នករំពឹងថានឹងទទួលបានពីម៉ាស៊ីនមេ។ ប្រសិនបើប្រភេទទិន្នន័យមិនត្រូវបានបញ្ជាក់នោះ jQuery នឹងព្យាយាមកំណត់វាដោយផ្អែកលើប្រភេទ MIME ពីការឆ្លើយតប ( XMLប្រភេទ MIMEលទ្ធផលនឹងជា XML គិតត្រឹម jQuery 1.4 ជេសុននឹងផ្តល់វត្ថុមួយ។ JavaScript, ស្គ្រីបនឹង​ប្រតិបត្តិ​ស្គ្រីប ហើយ​អ្វីៗ​ផ្សេងទៀត​នឹង​ត្រូវ​បាន​ត្រឡប់​ជា​ខ្សែអក្សរ)។


ប្រភេទមូលដ្ឋាន (លទ្ធផលត្រូវបានហុចជាអាគុយម៉ង់ដំបូងចំពោះមុខងារហៅត្រឡប់មកវិញជោគជ័យ)៖

• "xml" - ត្រឡប់ XMLឯកសារដែលអាចត្រូវបានបង្ហាញដោយប្រើ jQuery ។
• "html" - ត្រឡប់មកវិញ HTMLម៉េច អត្ថបទធម្មតា។ស្លាកនឹងត្រូវបានដំណើរការ និងប្រតិបត្តិបន្ទាប់ពីការបញ្ចូលទៅក្នុង គំរូវត្ថុឯកសារ ( DOM).
• "ស្គ្រីប" - វាយតម្លៃការឆ្លើយតបជា JavaScriptហើយត្រឡប់វាជាអត្ថបទធម្មតា។ បិទដំណើរការឃ្លាំងសម្ងាត់ដោយបន្ថែមប៉ារ៉ាម៉ែត្រ _= ទៅខ្សែអក្សរសំណួរ ទោះបីជាប៉ារ៉ាម៉ែត្រឃ្លាំងសម្ងាត់ពិតក៏ដោយ។ នេះនឹងបង្វែរវិធីសាស្រ្ត ប្រកាសវ ក្បាលសម្រាប់សំណើឆ្លងដែន។
• "json" - វាយតម្លៃការឆ្លើយតបជា JSONហើយត្រឡប់វត្ថុមួយ។ JavaScript. ឆ្លងដែន "json"សំណើត្រូវបានបំប្លែងទៅជា "jsonp"ប្រសិនបើ jsonp មិនត្រូវបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រសំណើ៖ មិនពិត។ JSONទិន្នន័យ JSONត្រូវ​បាន​ញែក​តាម​លំដាប់​យ៉ាង​តឹងរ៉ឹង ហើយ​ត្រូវ​តែ​អនុលោម​តាម​ទម្រង់​ដែល​ទទួល​យក​ជា​ទូទៅ មិន​ត្រឹម​ត្រូវ
• ត្រូវបានច្រានចោល ហើយកំហុសមួយត្រូវបានបោះចោល។ ចាប់ពី jQuery 1.9 ការឆ្លើយតបទទេមិនត្រូវបានទទួលយកទេ ម៉ាស៊ីនមេត្រូវតែត្រឡប់ NULL ឬ () ជាការឆ្លើយតប។ JSON"jsonp" - ផ្ទុកទិន្នន័យក្នុងទម្រង់ ដោយប្រើទម្រង់ទាញយក JSONP . បន្ថែមប៉ារ៉ាម៉ែត្របន្ថែម "?callback=?" ដល់ទីបញ្ចប់ URL . បន្ថែមប៉ារ៉ាម៉ែត្របន្ថែម "?callback=?" ដល់ទីបញ្ចប់អាសយដ្ឋាន ទោះបីជាប៉ារ៉ាម៉ែត្រឃ្លាំងសម្ងាត់ពិតក៏ដោយ។
• "អត្ថបទ" គឺជាខ្សែអក្សរធម្មតា។
• multiple values ​​- តម្លៃត្រូវបានបំបែកដោយដកឃ្លាមួយ។ ចាប់តាំងពីកំណែ 1.5, jQuery អាចបំប្លែងប្រភេទទិន្នន័យដែលត្រូវបានទទួល ចំណងជើងមាតិកា-ប្រភេទទៅកាន់ប្រភេទទិន្នន័យដែលអ្នកត្រូវការ។ ឧទាហរណ៍ ប្រសិនបើអ្នកចង់ឱ្យការឆ្លើយតបអត្ថបទត្រូវបានបកប្រែជា XML សូមប្រើ "អត្ថបទ XML" សម្រាប់ប្រភេទទិន្នន័យនោះ។ អ្នកក៏អាចធ្វើការស្នើសុំ JSONP ទទួលវាជាអត្ថបទ និងបកស្រាយវាជា XML៖ "jsonp text XML" ។ បន្ទាត់ខាងក្រោមនឹងធ្វើដូចគ្នា៖ "jsonp XML", jQuery នឹងព្យាយាមបំប្លែងពី ដោយប្រើទម្រង់ទាញយកវ XMLបន្ទាប់ពីការប៉ុនប៉ងមិនជោគជ័យនឹងព្យាយាមបំប្លែង ដោយប្រើទម្រង់ទាញយកចូលទៅក្នុងអត្ថបទ ហើយបន្ទាប់មកពីអត្ថបទទៅ XML.

• ប្រភេទ៖ មុខងារ(jqXHR ប្រភេទ៖ មុខងារ(jqXHR, ខ្សែអក្សរ ស្ថានភាពអត្ថបទ, ខ្សែអក្សរ កំហុសបោះចោល).
  មុខងារហៅត្រឡប់មកវិញដែលត្រូវបានហៅប្រសិនបើសំណើ AJAX មិនត្រូវបានបញ្ចប់។ មុខងារទទួលបានអាគុយម៉ង់បី៖

  • ប្រភេទ៖ មុខងារ(jqXHR- វត្ថុ jqXHR (ក្នុង jQuery 1.4.x, XMLHttpRequest object) ។
  • ស្ថានភាពអត្ថបទ- ខ្សែអក្សរដែលពិពណ៌នាអំពីប្រភេទនៃកំហុសដែលបានកើតឡើង។ តម្លៃដែលអាចធ្វើបាន (ក្រៅពី null) គឺមិនមែនទេ។ "អស់ពេល", "កំហុស", "ការរំលូតកូន""ស្គ្រីប" "parsereror".
  • កំហុសបោះចោល- វត្ថុករណីលើកលែងបន្ថែមប្រសិនបើបានកើតឡើង។ នៅពេលមានកំហុសកើតឡើង HTTPអាគុយម៉ង់ទទួលបានផ្នែកអត្ថបទនៃរដ្ឋ ឧ. "រកមិនឃើញ", ឬ "កំហុសម៉ាស៊ីនមេខាងក្នុង".
  ចាប់តាំងពីកំណែ អំពីការឆ្លើយតបរបស់ម៉ាស៊ីនមេ ហើយវត្ថុក៏មានវិធីសាស្ត្រសន្យាផងដែរ។ ប្រសិនបើអនុគមន៍ beforeSend ត្រឡប់មិនពិត នោះសំណើ AJAX នឹងត្រូវបានលុបចោល។ ចាប់តាំងពីកំណែវាត្រូវបានអនុញ្ញាតឱ្យឆ្លងកាត់អារេនៃមុខងារជាតម្លៃប៉ារ៉ាម៉ែត្រ ហើយមុខងារនីមួយៗនឹងត្រូវបានហៅតាមវេនរបស់វា។ ចំណាំថាអ្នកដោះស្រាយនេះមិនត្រូវបានហៅសម្រាប់ស្គ្រីបឆ្លងដែន និងសំណើ JSONP ទេ។

• សកល (លំនាំដើម៖ ពិត) ។

  ប្រភេទ៖ ប៊ូលីន។
  ប៉ារ៉ាម៉ែត្រ Boolean ដែលកំណត់ថាតើអ្នកដោះស្រាយព្រឹត្តិការណ៍ AJAX សកលត្រូវបានអនុញ្ញាតឱ្យហៅសម្រាប់សំណើនេះ។ តម្លៃលំនាំដើមគឺពិត។ ប្រសិនបើអ្នកត្រូវការការពារអ្នកដោះស្រាយព្រឹត្តិការណ៍សកលដូចជា .ajaxStart() ឬ .ajaxStop() ពីការហៅ បន្ទាប់មកប្រើមិនពិត។

  បឋមកថា (លំនាំដើម៖ ()) ។

  ប្រភេទ៖ PlainObject។
  វត្ថុដែលមានគូគន្លឹះ/តម្លៃនៃបឋមកថាសំណើបន្ថែមដែលត្រូវផ្ញើរួមជាមួយសំណើដោយប្រើវត្ថុ XMLHttpRequest ។ សូមចំណាំថាចំណងជើង X-Requested-With: XMLHttpRequestតែងតែត្រូវបានបន្ថែម ប៉ុន្តែតម្លៃនៃ XMLHttpRequest អាចត្រូវបានផ្លាស់ប្តូរតាមលំនាំដើមដោយប្រើប៉ារ៉ាម៉ែត្រនេះ។ តម្លៃបឋមកថាក៏អាចត្រូវបានបដិសេធដោយប៉ារ៉ាម៉ែត្រ beforeSend ។ បានបន្ថែមនៅក្នុង jQuery 1.5 ។

  ប្រសិនបើបានកែប្រែ (លំនាំដើម៖ មិនពិត)។

  ប្រភេទ៖ ប៊ូលីន។
  លំនាំដើមទៅមិនពិត មិនអើពើវាលបឋមកថា សំណើ HTTPហើយប្រសិនបើតម្លៃគឺពិត សំណើ AJAX ត្រូវបានផ្ទេរទៅស្ថានភាពដោយជោគជ័យ ( ជោគជ័យ) លុះត្រាតែការឆ្លើយតបពីម៉ាស៊ីនមេបានផ្លាស់ប្តូរចាប់តាំងពីការស្នើសុំចុងក្រោយ។ សុពលភាពត្រូវបានធ្វើដោយពិនិត្យមើលប្រអប់បឋមកថាដែលបានកែប្រែចុងក្រោយ។ ចាប់តាំងពីកំណែ jQuery 1.4បន្ថែមពីលើបឋមកថាដែលបានកែប្រែចុងក្រោយ "etag" ក៏ត្រូវបានពិនិត្យផងដែរ ( ស្លាកអង្គភាព) គឺជាឧបករណ៍កំណត់អត្តសញ្ញាណឯកជនដែលផ្តល់ដោយម៉ាស៊ីនមេគេហទំព័រទៅកំណែជាក់លាក់នៃធនធានដែលរកឃើញនៅ URL ។ ប្រសិនបើមាតិកាធនធានសម្រាប់អាសយដ្ឋាននេះផ្លាស់ប្តូរទៅអាសយដ្ឋានថ្មី etag ថ្មីត្រូវបានចាត់តាំង។

  isLocal (លំនាំដើម៖ អាស្រ័យលើទីតាំងបច្ចុប្បន្ន)។

  ប្រភេទ៖ ប៊ូលីន។
  ប្រើពិតដើម្បីកំណត់បរិយាកាសបច្ចុប្បន្នជា "មូលដ្ឋាន" (ឧទាហរណ៍ file:///url) ទោះបីជា jQuery មិនទទួលស្គាល់វាតាមលំនាំដើមក៏ដោយ។ បច្ចុប្បន្នពិធីការខាងក្រោមត្រូវបានទទួលស្គាល់ថាជាមូលដ្ឋាន៖ ឯកសារ, * - ផ្នែកបន្ថែម"ស្គ្រីប" ធាតុក្រាហ្វិក. ប្រសិនបើអ្នកត្រូវការផ្លាស់ប្តូរប៉ារ៉ាម៉ែត្រ isLocal វាត្រូវបានណែនាំអោយធ្វើម្តងដោយប្រើមុខងារ $.ajaxSetup()។ បានបន្ថែមនៅក្នុង jQuery 1.5.1 ។

  ប្រភេទ៖ ប៊ូលីន ឬខ្សែអក្សរ។
  បដិសេធឈ្មោះមុខងារហៅត្រឡប់មកវិញនៅក្នុង ដោយប្រើទម្រង់ទាញយកសំណើ។ តម្លៃនេះនឹងត្រូវបានប្រើជំនួសឱ្យ "ការហៅត្រឡប់មកវិញ" ( "http://domain.ru/test.php?callback=?") ដែលជាផ្នែកមួយនៃខ្សែអក្សរសំណួរនៅក្នុង អាសយដ្ឋាន URL e. ឧទាហរណ៍ តម្លៃ (jsonp: "onLoad") នឹងត្រូវបានផ្ញើទៅម៉ាស៊ីនមេក្នុងទម្រង់ បន្ទាត់បន្ទាប់សំណើ "http://domain/test.php?onLoad= ?".
  ចាប់តាំងពី jQuery 1.5 ការកំណត់ jsonp parameter ទៅ false រារាំងខ្សែអក្សរ "?callback" ពីការបន្ថែមទៅ URL ឬព្យាយាមប្រើ "=?" ដើម្បីដោះស្រាយការឆ្លើយតប។ ក្នុងករណីនេះ អ្នកត្រូវតែបញ្ជាក់បន្ថែមនូវតម្លៃនៃប៉ារ៉ាម៉ែត្រ jsonpCallback ឧទាហរណ៍៖ ( jsonp : false , jsonpCallback : "callbackName" ) សម្រាប់ហេតុផលសុវត្ថិភាព ប្រសិនបើអ្នកមិនជឿជាក់លើគោលដៅនៃសំណើ AJAX របស់អ្នកទេ វាត្រូវបានណែនាំអោយ កំណត់តម្លៃនៃប៉ារ៉ាម៉ែត្រ jsonp ទៅមិនពិត។

  jsonpCallback ។

  ប្រភេទ៖ ខ្សែអក្សរ ឬមុខងារ។
  បញ្ជាក់​ឈ្មោះ​មុខងារ callback សម្រាប់ ដោយប្រើទម្រង់ទាញយកសំណើ។ តម្លៃនេះនឹងត្រូវបានប្រើជំនួសឱ្យឈ្មោះចៃដន្យដែលត្រូវបានបង្កើត និងកំណត់ដោយ jQuery ដោយស្វ័យប្រវត្តិ។ វាត្រូវបានណែនាំថា jQuery បង្កើតឈ្មោះតែមួយគត់ដោយខ្លួនឯង វានឹងធ្វើឱ្យវាកាន់តែងាយស្រួលក្នុងការគ្រប់គ្រងសំណើ និងដោះស្រាយកំហុសដែលអាចកើតមាន។ ក្នុងករណីខ្លះ ការកំណត់ឈ្មោះមុខងារផ្ទាល់ខ្លួនរបស់អ្នកនឹងធ្វើឱ្យឃ្លាំងសម្ងាត់កម្មវិធីរុករកប្រសើរឡើង ក្បាលសំណើ។
  ចាប់តាំងពី jQuery 1.5 អ្នកអាចបញ្ជាក់មុខងារជាតម្លៃនៃប៉ារ៉ាម៉ែត្រ jsonpCallback ។ ក្នុងករណីនេះ តម្លៃនៃប៉ារ៉ាម៉ែត្រ jsonpCallback ត្រូវតែកំណត់ទៅតម្លៃត្រឡប់នៃអនុគមន៍នេះ។

  វិធីសាស្រ្ត (លំនាំដើម៖ "ទទួលបាន").

  ប្រភេទ៖ ខ្សែអក្សរ។
  វិធីសាស្រ្ត HTTPប្រើសម្រាប់សំណួរ (ឧទាហរណ៍ "ប្រកាស", "ទទួលបាន", "PUT") បានបន្ថែមនៅក្នុង jQuery 1.9.0 ។

  ប្រភេទ mime ។

  ប្រភេទ៖ ខ្សែអក្សរ។
  ប្រភេទ MIME ដែលបដិសេធប្រភេទ MIME លំនាំដើមដែលបានបញ្ជាក់នៅក្នុងវត្ថុ XHR ។ បានបន្ថែមនៅក្នុង jQuery 1.5.1 ។

  ពាក្យសម្ងាត់។

  ប្រភេទ៖ ខ្សែអក្សរ។
  ពាក្យ​សម្ងាត់​ដែល​នឹង​ត្រូវ​បាន​ប្រើ​ជា​មួយ​នឹង XMLHttpRequest ក្នុង​ការ​ឆ្លើយ​តប​ទៅ​នឹង​សំណើ​ផ្ទៀងផ្ទាត់​សិទ្ធិ​ចូល​ដំណើរ​ការ HTTP.

  ទិន្នន័យដំណើរការ (លំនាំដើម៖ ពិត) ។

  ប្រភេទ៖ ប៊ូលីន។
  តាមលំនាំដើម ទិន្នន័យដែលបានបញ្ជូនទៅប៉ារ៉ាម៉ែត្រទិន្នន័យជាវត្ថុមួយនឹងត្រូវបានដំណើរការ និងបំប្លែងទៅជាខ្សែអក្សរសំណួរដែលសមរម្យសម្រាប់ប្រភេទទិន្នន័យលំនាំដើម "application/x-www-form-urlencoded". ប្រសិនបើអ្នកត្រូវការផ្ញើ DOMDocument ឬទិន្នន័យដែលមិនបានដំណើរការផ្សេងទៀត បន្ទាប់មកកំណត់ប៉ារ៉ាម៉ែត្រនេះទៅជាមិនពិត។

  scriptCharset ។

  ប្រភេទ៖ ខ្សែអក្សរ។
  កំណត់គុណលក្ខណៈតួអក្សរ (ការអ៊ិនកូដតួអក្សរ) ទៅស្លាក HTML ដែលប្រើក្នុងសំណើ។ ប្រើនៅពេលដែលការអ៊ិនកូដនៅលើទំព័រខុសពីការអ៊ិនកូដនៃស្គ្រីបពីចម្ងាយ។ សូមចំណាំថាប៉ារ៉ាម៉ែត្រ scriptCharset អនុវត្តតែចំពោះសំណើឆ្លងដែនដែលមានប៉ារ៉ាម៉ែត្រប្រភេទជាមួយនឹងតម្លៃ "ទទួលបាន"(លំនាំដើម) និងប៉ារ៉ាម៉ែត្រប្រភេទទិន្នន័យជាមួយនឹងតម្លៃ "jsonp", ឬ ឃ្លាំងសម្ងាត់ (លំនាំដើម៖ ពិត សម្រាប់ប្រភេទទិន្នន័យ.

  លេខកូដស្ថានភាព (លំនាំដើម៖ ()) ។

  ប្រភេទ៖ PlainObject។
  វត្ថុកូដលេខ HTTPនិងមុខងារដែលនឹងត្រូវបានហៅនៅពេលដែលលេខកូដឆ្លើយតបរបស់ម៉ាស៊ីនមេមានតម្លៃសមស្រប (លេខកូដជាក់លាក់ HTTP) ឧ. មុខងារបន្ទាប់នឹងត្រូវបានហៅប្រសិនបើលេខកូដឆ្លើយតបត្រូវបានទទួលពីម៉ាស៊ីនមេ 404 , ឬ "រកមិនឃើញ" (កូដស្តង់ដារការឆ្លើយតប HTTP ដែលបង្ហាញថាអតិថិជនអាចទំនាក់ទំនងជាមួយម៉ាស៊ីនមេបាន ប៉ុន្តែម៉ាស៊ីនមេមិនអាចស្វែងរកទិន្នន័យតាមការស្នើសុំបានទេ។): $.ajax(( statusCode : ( 404: function ()( // ប្រតិបត្តិមុខងារប្រសិនបើកូដឆ្លើយតប HTTP គឺ 404 alert("page not found");

  ជោគជ័យ។

  ប្រភេទ៖ មុខងារ (អ្វីទាំងអស់។ ទិន្នន័យ, ខ្សែអក្សរ ស្ថានភាពអត្ថបទ,jqXHR ប្រភេទ៖ មុខងារ(jqXHR).
  មុខងារហៅត្រឡប់មកវិញដែលត្រូវបានហៅប្រសិនបើសំណើ AJAX ទទួលបានជោគជ័យ។

  • ទិន្នន័យមុខងារត្រូវបានឆ្លងកាត់អាគុយម៉ង់បី:
  • ស្ថានភាពអត្ថបទ- ទិន្នន័យត្រឡប់ពីម៉ាស៊ីនមេ។ ទិន្នន័យ​ត្រូវ​បាន​ធ្វើ​ទ្រង់ទ្រាយ​តាម​ប៉ារ៉ាម៉ែត្រ dataType ឬ dataFilter ប្រសិនបើ​បាន​បញ្ជាក់
  • ប្រភេទ៖ មុខងារ(jqXHR- ខ្សែអក្សរពិពណ៌នាអំពីស្ថានភាពនៃសំណើ។ - វត្ថុ jqXHR (រហូតដល់កំណែ jQuery 1.4.x
  XMLHttp ស្នើសុំវត្ថុ) ។ អំពីការឆ្លើយតបរបស់ម៉ាស៊ីនមេ ហើយវត្ថុក៏មានវិធីសាស្ត្រសន្យាផងដែរ។ ប្រសិនបើអនុគមន៍ beforeSend ត្រឡប់មិនពិត នោះសំណើ AJAX នឹងត្រូវបានលុបចោល។ ចាប់តាំងពីកំណែចាប់តាំងពីកំណែ

• វាត្រូវបានអនុញ្ញាតឱ្យឆ្លងកាត់អារេនៃមុខងារជាតម្លៃប៉ារ៉ាម៉ែត្រ ហើយមុខងារនីមួយៗនឹងត្រូវបានហៅតាមវេនរបស់វា។

  អស់ពេល។
  ប្រភេទ៖ លេខ។ ដំឡើងនៅក្នុងមិល្លីវិនាទី 0 ស្នើសុំអស់ពេល។ អត្ថន័យ

  មាន​ន័យ​ថា​មិន​បាន​កំណត់​ពេល​វេលា​។ សូមចំណាំថាប៉ារ៉ាម៉ែត្រនេះបដិសេធតម្លៃអស់ពេលដែលបានកំណត់ដោយប្រើមុខងារ $.ajaxSetup() ។ ពេលវេលារង់ចាំចាប់ផ្តើមនៅពេលដែលវិធីសាស្ត្រ $.ajax() ត្រូវបានហៅ។

  ប្រភេទ៖ ប៊ូលីន។
  ប្រសិនបើអ្នកមានគម្រោងប្រើជម្រើសសៀរៀលប្រពៃណី (សាកសមសម្រាប់ប្រើក្នុងខ្សែអក្សរ . បន្ថែមប៉ារ៉ាម៉ែត្របន្ថែម "?callback=?" ដល់ទីបញ្ចប់ស្នើសុំឬស្នើសុំ AJAX) បន្ទាប់មកកំណត់តម្លៃនៃប៉ារ៉ាម៉ែត្រនេះទៅពិត។

  ប្រភេទ (លំនាំដើម៖ "ទទួលបាន").

  ប្រភេទ៖ ខ្សែអក្សរ។
  ឈ្មោះក្លែងក្លាយសម្រាប់ប៉ារ៉ាម៉ែត្រវិធីសាស្រ្ត។ អ្នកគួរតែប្រើប្រភេទ ប្រសិនបើអ្នកកំពុងប្រើកំណែ jQuery មុន 1.9.0.

  url (លំនាំដើម៖ ទំព័របច្ចុប្បន្ន).

  ប្រភេទ៖ ខ្សែអក្សរ។
  បន្ទាត់ដែលមាន . បន្ថែមប៉ារ៉ាម៉ែត្របន្ថែម "?callback=?" ដល់ទីបញ្ចប់អាសយដ្ឋានដែលសំណើត្រូវបានផ្ញើ។

  ឈ្មោះអ្នកប្រើប្រាស់។

  ប្រភេទ៖ ខ្សែអក្សរ។
  ឈ្មោះអ្នកប្រើដែលត្រូវប្រើជាមួយ XMLHttpRequest ក្នុងការឆ្លើយតបទៅនឹងសំណើការផ្ទៀងផ្ទាត់សិទ្ធិចូលប្រើ HTTP.

  xhr (លំនាំដើម៖ ActiveXObjectនៅពេលមាន ( Internet Explorer ) ក្នុងករណីផ្សេងទៀត XMLHttpRequest .

  ប្រភេទ៖ មុខងារ()។
  ហៅត្រឡប់មកវិញដើម្បីបង្កើតវត្ថុ XMLHttpRequest ។ ជាមួយនឹងប៉ារ៉ាម៉ែត្រនេះ អ្នកអាចបដិសេធវត្ថុ XMLHttpRequest ដើម្បីផ្តល់នូវការអនុវត្តផ្ទាល់ខ្លួនរបស់អ្នក។

  xhrFields ។

  ប្រភេទ៖ PlainObject។
  វត្ថុដែលមាន field_name:field_value pairs ដែលនឹងត្រូវបានកំណត់ទៅវត្ថុ XHR ។ ឧទាហរណ៍ អ្នកអាចកំណត់ថាតើសំណើឆ្លងដែនគួរត្រូវបានបង្កើតដោយប្រើលិខិតសម្គាល់ដូចជា ខូគីចំណងជើងការអនុញ្ញាត ឬវិញ្ញាបនបត្រ TLS៖ $.ajax(( url : "cross_domain_url", // អាសយដ្ឋានដែលសំណើនឹងត្រូវបានផ្ញើ xhrFields : ( withCredentials: true // supported in jQuery 1.5.1 + ) ) );

អត្ថបទនេះត្រូវបានសរសេរជាយូរមកហើយ - 08/03/2010

ដូចដែលបានសន្យា ខ្ញុំបន្តស៊េរីនៃអត្ថបទនៅលើ JQuery ដែលជាក្របខ័ណ្ឌ JavaScript ដ៏ល្អដែលអ្នកអាចធ្វើអ្វីគ្រប់យ៉ាង!

នៅក្នុងអត្ថបទចុងក្រោយយើងបាននិយាយអំពី JQuery ជាទូទៅ - យើងបានមើលគោលការណ៍នៃប្រតិបត្តិការរបស់វាហើយឧទាហរណ៍សាមញ្ញបំផុតត្រូវបានផ្តល់ឱ្យ។ នៅក្នុងអត្ថបទនេះយើងនឹងប៉ះលើប្រធានបទដូចជា AJAX ជាមួយ ដោយប្រើ JQuery(ជាមួយឧទាហរណ៍) ។

xmlHttp សំណើ

តើអ្នកដឹងថា xmlHttpRequest ជាអ្វីទេ? XmlHttpRequest គឺ​ជា​វត្ថុ​ដែល​អនុញ្ញាត​ឱ្យ​កម្មវិធី​រុករក​ធ្វើ​សំណើ​ទៅ​កាន់​ម៉ាស៊ីន​មេ​ដោយ​មិន​បាច់​ផ្ទុក​ទំព័រ​ឡើង​វិញ។ ហើយនេះជាការពិតគឺច្បាស់ពីឈ្មោះ: សំណើ http - សំណើសម្រាប់ ពិធីការ http. ប៉ុន្តែជាមួយនឹង xml វាគួរឱ្យចាប់អារម្មណ៍ជាងនេះទៅទៀត៖ ទោះបីជាមានការបង្ហាញពីភាសានេះនៅក្នុងឈ្មោះក៏ដោយ វត្ថុ XHR (នេះគឺខ្លីសម្រាប់ xmlHttpRequest) ដំណើរការជាមួយទិន្នន័យនៃទ្រង់ទ្រាយណាមួយ មិនត្រឹមតែជាមួយ XML ប៉ុណ្ណោះទេ។ តាមពិតបច្ចេកវិទ្យា Ajax គឺផ្អែកលើសមាសធាតុនេះ។ អ្នកអាចអានបន្ថែមអំពីវានៅលើគេហទំព័រ xmlhttprequest.ru អ្នកអាចមើលឧទាហរណ៍នៃការប្រើប្រាស់នៅ អត្ថបទអំពី CURLeប៉ុន្តែ នេះ​ជា​ការ​ចាប់​អារម្មណ៍​តិច​តួច​សម្រាប់​យើង​ឥឡូវ​នេះ។ ឥឡូវនេះសូមមើល Ajax ដោយប្រើ JQuery ។

jQuery AJAX

ដូចរាល់ដង - ពីសាមញ្ញទៅស្មុគស្មាញ៖

$.ajax(( url: "/ajax.php?act=jquery_test", // URL ដែលយើងកំពុងចូលប្រើប្រភេទ៖ "ទទួល", // ប្រភេទ៖ អាច GET ឬ POST (បន្ថែមលើនោះខាងក្រោម)ជោគជ័យ៖ មុខងារ (ឆ្លើយតប) ( // ជោគជ័យ - មុខងារមួយដែលត្រូវបានហៅនៅពេលដែលការស្នើសុំទទួលបានជោគជ័យ ហើយទិន្នន័យត្រូវបានទទួល alert("ម៉ាស៊ីនមេបានឆ្លើយតបមកវិញ៖ " + ការឆ្លើយតប);

) ));

នេះគឺជាឧទាហរណ៍សាមញ្ញបំផុតនៃការប្រើប្រាស់ ajax នៅក្នុង JQuery ។ ឥឡូវនេះសូមមើលពីរបៀបដែលអ្នកអាចផ្ញើទិន្នន័យទៅម៉ាស៊ីនមេដោយប្រើវិធីសាស្ត្រ POST៖ $.ajax(( url: "/ajax.php?act=ajax_jquery_post", ប្រភេទ: "POST", ប្រភេទមាតិកា: "application/x-www-form-urlencoded", //ប្រភេទនៃទិន្នន័យដែលបានបញ្ជូន ទិន្នន័យ៖ "text="+$("#text").val() +"&id=282&c=w", //ហើយនេះជាការពិត ទិន្នន័យ (បំពាន)

ជោគជ័យ៖ មុខងារ(ការឆ្លើយតប)( ដាស់តឿន("ទិន្នន័យបានផ្ញើ! ម៉ាស៊ីនមេបានត្រឡប់ការឆ្លើយតបវិញ៖ " + ការឆ្លើយតប); ) ));

នេះគឺជាឧទាហរណ៍នៃការផ្ញើទិន្នន័យទៅកាន់ម៉ាស៊ីនមេដោយប្រើ JQuery AJAX ។ ឥឡូវនេះបន្តិចអំពីទម្រង់ផ្សេងទៀត៖ $.ajax(( url: "ajax.php?act=ajax_jquery", ប្រភេទ: "POST", dataType: "JSON", //ទម្រង់អាចជា៖ JSON, XML, HTML, អត្ថបទ និងមួយចំនួនផ្សេងទៀត។

ទិន្នន័យ៖ ទិន្នន័យខ្លះជោគជ័យ៖ មុខងារ (ការឆ្លើយតប) ( // សកម្មភាពមួយចំនួន ) ));

• បន្ថែមពីលើការពិតដែលថាយើងអាចភ្ជាប់អ្នកដោះស្រាយសម្រាប់ព្រឹត្តិការណ៍ "ជោគជ័យ" យើងក៏អាចភ្ជាប់ការដោះស្រាយព្រឹត្តិការណ៍ផ្សេងទៀតផងដែរ:
• ជោគជ័យត្រូវបានគេហៅថានៅពេលដែលសំណើបានជោគជ័យ។ វាត្រូវបានឆ្លងកាត់ប៉ារ៉ាម៉ែត្រ៖ ទិន្នន័យត្រឡប់ដោយម៉ាស៊ីនមេ ខ្សែអក្សរដែលមានលេខកូដឆ្លើយតបរបស់ម៉ាស៊ីនមេ និងវត្ថុ xmlHttpRequest ។
• កំហុសត្រូវបានហៅនៅពេលសំណើបរាជ័យ។ បានផ្ញើ៖ xmlHttpRequest និងខ្សែអក្សរដែលបង្ហាញពីប្រភេទកំហុស
• ពេញលេញត្រូវបានហៅនៅពេលដែលសំណើបានបញ្ចប់។ វាទើបតែបញ្ចប់ ថាតើវាជាសំណាងឬអត់។ បានផ្ញើ៖ xmlHttpRequest និងខ្សែអក្សរដែលបង្ហាញពីជោគជ័យ ឬកូដកំហុស។
• តម្រងទិន្នន័យត្រូវបានហៅ មុនពេលជោគជ័យត្រូវបានគេហៅថា។ ទិន្នន័យដែលទទួលបានពីម៉ាស៊ីនមេត្រូវបានបញ្ជូនទៅវា។ ក្នុង​នោះ​យើង​អាច​ធ្វើ​ការងារ​មួយ​ចំនួន​ជាមួយ​ទិន្នន័យ​ហើយ​ត្រូវ​តែ​ត្រឡប់​វា​វិញ (return...)។ ប្រសិនបើមានមុខងារនេះ នោះអ្វីដែលយើងត្រឡប់ពី dataFilter ទទួលបានភាពជោគជ័យ

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

ឥឡូវឧទាហរណ៍៖ $.ajax(( url: "ajax.php?act=something" ប្រភេទ: "GET", //អ្វីទាំងអស់។ យើងទទួលបានភាពជោគជ័យ៖ មុខងារ (ការឆ្លើយតបលេខកូដ) ( //បាទ/ចាស យើងខកខានប៉ារ៉ាម៉ែត្រចុងក្រោយ - យើងមិនត្រូវការវាទេ។ if (code==200)( alert("ម៉ាស៊ីនមេបានត្រឡប់មកវិញ៖ " + ការឆ្លើយតប); )else( alert("ម៉ាស៊ីនមេបានបញ្ជូនលេខកូដឆ្លើយតបចម្លែកមួយចំនួន៖ " + កូដ); ) , error: function(xhr, str) ( alert("កំហុសមួយបានកើតឡើង៖ " + xhr.responseCode); ) បញ្ចប់៖ មុខងារ())( //ហើយនៅទីនេះយើងមិនយកប៉ារ៉ាម៉ែត្រណាមួយដែលបានស្នើឡើង :) ឧទាហរណ៍ ពួកគេបានលាក់ប៊ូតុងមួយចំនួនដែលបណ្តាលឱ្យមានការស្នើសុំ } });

នេះ​គឺ​ជា​ឧទាហរណ៍​វិជ្ជាជីវៈ​ធ្ងន់ធ្ងរ​ជាង​នេះ ដើម្បី​និយាយ​ជាមួយ​នឹង​ការ​ដោះស្រាយ​កំហុស។

jQuery.ajaxSetup()

មានវិធីសាស្រ្តដ៏អស្ចារ្យបែបនេះនៅក្នុង JQuery - ajaxSetup ។ ដោយមានជំនួយរបស់វា អ្នកអាចកំណត់ជម្រើសចាំបាច់ទាំងអស់ជាសកលនៅទូទាំងស្គ្រីបទាំងមូល។ ឧទាហរណ៍៖

$(document).ready(function())( $.ajaxSetup(( url: "ajax.php", type: "POST", success: function(data)($("#somefield").val(data) ;) error: function())($("#somebutton").addClass("error"); ) )); $("#somebutton1").click(function())($.ajax((data: "act=1")); )); $("#some2").click(function())($.ajax((data: "act=2")); ));

ជម្រើស $.ajax

ហើយឥឡូវនេះ ដោយបានអនុវត្តតិចតួច ខ្ញុំនឹងប្រាប់អ្នកពីផ្នែកទ្រឹស្តី - អំពីជម្រើស JQuery Ajax

• async (ពិតឬមិនពិត)។ លំនាំដើមទៅពិត។ បើក ឬបិទសំណើអសមកាល (សូមមើល xmlHttpRequest component)។ សូមចងចាំថាដោយការបើកសំណើសមកាលកម្ម អ្នកអាចគាំងកម្មវិធីរុករករបស់អ្នក!
• ឃ្លាំងសម្ងាត់ (ពិតឬមិនពិត) ។ បើក ឬបិទដំណើរការឃ្លាំងសម្ងាត់កម្មវិធីរុករក
• ប្រភេទមាតិកា (ខ្សែអក្សរ) ។ ប្រភេទនៃមាតិកាដែលបានផ្ញើទៅម៉ាស៊ីនមេ។ នៅពេលបញ្ជូនទម្រង់ សូមប្រើកម្មវិធី/x-www-form-urlencoded
• ទិន្នន័យ (ខ្សែអក្សរ) ។ ទិន្នន័យត្រូវបានបញ្ជូនទៅម៉ាស៊ីនមេ។
• ប្រភេទទិន្នន័យ (ខ្សែអក្សរ) ។ ប្រភេទទិន្នន័យដែលរំពឹងទុកពីម៉ាស៊ីនមេ។ ប្រសិនបើគ្មានអ្វីត្រូវបានបញ្ជាក់ JQuery នឹងព្យាយាមកំណត់លទ្ធផលដោយផ្អែកលើប្រភេទ MIME នៃការឆ្លើយតប។ អាចយកតម្លៃ៖ xml, json, script, html ។
• ប្រសិនបើបានកែប្រែ (ពិតឬមិនពិត (លំនាំដើម)) ។ ប្រសិនបើកំណត់ទៅពិត សំណើនឹងជោគជ័យលុះត្រាតែការឆ្លើយតបបានផ្លាស់ប្តូរចាប់តាំងពីសំណើចុងក្រោយ (សម្រេចបានដោយការពិនិត្យមើលបឋមកថាចុងក្រោយដែលបានកែប្រែ)
• អស់ពេល (គិតជាមិល្លីវិនាទី)។ តម្លៃបន្ទាប់ពីការភ្ជាប់ទៅម៉ាស៊ីនមេនឹងត្រូវបានបញ្ចប់ (អស់ពេល)
• ប្រភេទ (ខ្សែអក្សរ៖ GET ឬ POST) ។ ប្រភេទនៃសំណើទៅកាន់ម៉ាស៊ីនមេ៖ ទទួល ឬបង្ហោះ
• url (ខ្សែអក្សរ) ។ ទំព័រម៉ាស៊ីនមេដែលសំណើនឹងត្រូវបានធ្វើឡើង។

ដូច្នេះយើងបានរកឃើញ Ajax នៅលើ JQuery ។ រង់ចាំ អត្ថបទបន្ទាប់- វានឹងមើលទៅអ្វីដែលឆ្ងាញ់ដោយប្រើ JQuery ;)