JSON (JavaScript Object Notation) គឺជាទម្រង់សម្រាប់ផ្លាស់ប្តូរទិន្នន័យក្នុងទម្រង់ជាអត្ថបទ។ អនុញ្ញាតឱ្យផ្ទេររចនាសម្ព័ន្ធទិន្នន័យស្មុគស្មាញក្នុងទម្រង់សៀរៀល។ ទម្រង់ផ្ទេរទិន្នន័យនេះបានក្លាយជាការពេញនិយមយ៉ាងខ្លាំងដែលរួចហើយនៅក្នុងស្នូល PHP ចាប់ផ្តើមជាមួយនឹងកំណែ 5.2.0 មុខងារសម្រាប់ដំណើរការទិន្នន័យក្នុងទម្រង់នេះត្រូវបានបន្ថែម។ នេះមានន័យថាមិនចាំបាច់ភ្ជាប់ទេ។ ផ្នែកបន្ថែម. ទម្រង់ទិន្នន័យ JSON គឺអាចអានបានដោយមនុស្ស។ ក្រៅពីនេះ។ ប្រភេទនេះ។ការផ្លាស់ប្តូរទិន្នន័យត្រូវបានប្រើប្រាស់យ៉ាងទូលំទូលាយរវាងសេវាកម្ម API ផ្សេងៗ។ ហើយជាមួយនឹងការអភិវឌ្ឍន៍ត្រឹមត្រូវនៃក្បួនដោះស្រាយសម្រាប់ការផ្លាស់ប្តូរព័ត៌មាន អ្នកអាចទទួលបានល្បឿនខ្ពស់ខ្លាំងជាងឧទាហរណ៍ នៅពេលធ្វើការជាមួយទិន្នន័យក្នុងទម្រង់ XML ។
កំពុងផ្ញើទិន្នន័យផ្ញើទិន្នន័យទៅ ទម្រង់ JSONអាចធ្វើបានតាមពីរវិធី៖ បង្កើត GET ឬ សំណើ POSTជាមួយនឹងទិន្នន័យដែលបានអ៊ិនកូដដែលមានទីតាំងនៅ GET ឬ អថេរ POSTឬដាក់ទិន្នន័យនៅក្នុងតួឯកសារ។ នៅក្នុងការអនុវត្តជម្រើសទីពីរត្រូវបានប្រើជាធម្មតា។
ដើម្បីផ្ញើទិន្នន័យ មុខងារខាងក្រោមត្រូវបានទាមទារ៖
- ខ្សែអក្សរ json_encode (តម្លៃចម្រុះ [, ជម្រើស int = 0])
ប៉ារ៉ាម៉ែត្រតម្លៃបញ្ជាក់ទិន្នន័យដែលត្រូវការអ៊ិនកូដ។ ប្រភេទណាមួយត្រូវបានគាំទ្រ លើកលែងតែប្រភេទ ធនធាន. ប៉ារ៉ាម៉ែត្រជម្រើសមាន bitmask នៃតម្លៃដែលអាចធ្វើទៅបាន (សូមមើលតារាងដែលមានចំនួន JSON ថេរ) ។
- ធនធាន stream_context_create (])
មុខងារនេះត្រូវបានរចនាឡើងដើម្បីបង្កើត និងត្រឡប់បរិបទខ្សែស្រឡាយជាមួយនឹងជម្រើសដែលបានបញ្ជាក់នៅក្នុងប៉ារ៉ាម៉ែត្រជម្រើស។ ប៉ារ៉ាម៉ែត្រជម្រើសជាជម្រើសត្រូវតែជាប្រភេទអារេពាក់ព័ន្ធ។ ដំបូងវាទទេ។ ប៉ារ៉ាម៉ែត្រប៉ារ៉ាម៉ែត្រជម្រើសទីពីរក៏ត្រូវតែជាអារេពាក់ព័ន្ធក្នុងទម្រង់ $data['name'] = តម្លៃ។
- string file_get_contents (ឈ្មោះឯកសារខ្សែអក្សរ [, bool use_include_path [, បរិបទធនធាន [, int offset [, int maxlen]]]])
ការប្រើប្រាស់មុខងារនេះអនុញ្ញាតឱ្យអ្នកទទួលបានមាតិកានៃឯកសារជាខ្សែអក្សរ។ ប៉ារ៉ាម៉ែត្រឈ្មោះឯកសារគឺជាឈ្មោះឯកសារដែលត្រូវអាន។ នៅក្នុងប៉ារ៉ាម៉ែត្រ use_include_path ចាប់ផ្តើមពី កំណែ PHP 5 អ្នកអាចប្រើថេរ FILE_USE_INCLUDE_PATHដើម្បីស្វែងរកឯកសារនៅក្នុងផ្លូវរួមបញ្ចូល។ ប៉ារ៉ាម៉ែត្របរិបទតំណាងឱ្យធនធានបរិបទដែលបានបង្កើតដោយប្រើមុខងារ stream_context_create() ។ ប្រសិនបើការព្យាយាមបើកឯកសារបរាជ័យ តម្លៃនឹងត្រូវបានត្រឡប់មកវិញ មិនពិត. ប៉ារ៉ាម៉ែត្រអុហ្វសិតមានអុហ្វសិតដែលការអានទិន្នន័យនឹងចាប់ផ្តើម។ ប៉ារ៉ាម៉ែត្រ maxlen បញ្ជាក់ទំហំនៃទិន្នន័យដែលទទួលបាន។
ចំណាំ៖ អុហ្វសិតមិនត្រូវបានបញ្ជាក់នៅពេលធ្វើការជាមួយខ្សែស្រឡាយពីចម្ងាយទេ។
ខាងក្រោមនេះជាឧទាហរណ៍នៃការផ្ញើទិន្នន័យក្នុងទម្រង់ JSON៖
// ទិន្នន័យដែលត្រូវផ្ញើ $request = array("StartDate" => "2013-10-10", "EndDate" => "2013-10-10", "IDS" => array(1,2,3,4 ,5,6,7)); // ការបញ្ជាក់ជម្រើសសម្រាប់បរិបទស្ទ្រីម $options = array ("http" => array ("method" => "POST", "header" => "Content-Type: application/json; charset=utf-8\r \n", "មាតិកា" => json_encode($request))); // បង្កើតបរិបទស្ទ្រីម $context = stream_context_create($options); // ការផ្ញើទិន្នន័យ និងទទួលបានលទ្ធផល echo file_get_contents("http://test.ru/json.php", 0, $context);
នៅទីនេះ រចនាសម្ព័ន្ធទិន្នន័យ improvised ត្រូវបានប្រើ ដែលរួមមានកាលបរិច្ឆេទចាប់ផ្តើម និងកាលបរិច្ឆេទបញ្ចប់ ក៏ដូចជាអារេនៃលេខមួយចំនួន។ ធាតុតាមលក្ខខណ្ឌ. សូមចំណាំថានៅក្នុងក្បាលសំណើ ប្រភេទមាតិកាប្រភេទ “application/json” ត្រូវបានបញ្ជាក់។
ការទទួលទិន្នន័យដើម្បីទទួលបានទិន្នន័យដែលបានបញ្ជូន តាមរបៀបដែលបានពិពណ៌នាខាងលើអ្នកត្រូវអានទិន្នន័យពីស្ទ្រីមបញ្ចូល " php:// បញ្ចូល”.
មុខងារប្រើដើម្បីទទួលយកទិន្នន័យ៖
- json_decode ចម្រុះ (ខ្សែអក្សរ json [, bool assoc = មិនពិត [, int depth = 512 [, ជម្រើស int = 0]]])
មុខងារនេះឌិកូដខ្សែអក្សរក្នុងទម្រង់ JSON ។ ប៉ារ៉ាម៉ែត្រ json បញ្ជាក់ខ្សែអក្សរដើម្បីឌិកូដ។ ប៉ារ៉ាម៉ែត្រ assoc កំណត់ថាតើទិន្នន័យដែលបានត្រឡប់មកវិញនឹងត្រូវបានបំប្លែងទៅជា អារេពាក់ព័ន្ធ. ប្រសិនបើមានតម្រូវការបែបនេះ អ្នកត្រូវតែបញ្ជាក់ជាតម្លៃនៃប៉ារ៉ាម៉ែត្រនេះ។ ពិត. ប៉ារ៉ាម៉ែត្រជម្រៅបង្ហាញពីជម្រៅការប្រើឡើងវិញ។ ហើយប៉ារ៉ាម៉ែត្រទីបួនចុងក្រោយ ជម្រើសមាន bitmask នៃជម្រើសសម្រាប់ការឌិកូដ។ បច្ចុប្បន្ននេះបានគាំទ្រតែប៉ុណ្ណោះ។ JSON_BIGINT_AS_STRING(តាមលំនាំដើម ចំនួនគត់ធំត្រូវបានបំប្លែងទៅជាលេខអណ្តែត (float))
- fopen ធនធាន (ឈ្មោះឯកសារខ្សែអក្សរ របៀបខ្សែអក្សរ [, bool use_include_path [, បរិបទធនធាន]])
បើកឯកសារមួយ ហើយត្រឡប់ចំណុចទាញរបស់វា។ ប៉ារ៉ាម៉ែត្រឈ្មោះឯកសារគឺជាធនធានដែលមានឈ្មោះចង្អុលទៅឯកសារ។ ប៉ារ៉ាម៉ែត្ររបៀបបញ្ជាក់ប្រភេទនៃការចូលប្រើឯកសារ (សូមមើលតារាងដែលមានបញ្ជី របៀបដែលអាចធ្វើបានសម្រាប់ fopen ()) ។ បន្ទាប់គឺជាប៉ារ៉ាម៉ែត្រស្រេចចិត្តពីរ៖ use_include_path និងបរិបទ។ នៅពេលកំណត់ use_include_path ទៅ ពិតឬ 1 និងផ្តល់ថាធនធានដែលមានឈ្មោះត្រូវបានកំណត់ ផ្លូវដែលទាក់ទងឯកសារដែលត្រូវបើកនឹងត្រូវបានស្វែងរកក្នុងបញ្ជីថតដែលប្រើដោយមុខងារ រួមបញ្ចូលនិង ទាមទារ. នៅក្នុងការអនុវត្តប៉ារ៉ាម៉ែត្រនេះមិនត្រូវបានអនុវត្តទេ។ ប៉ារ៉ាម៉ែត្របរិបទត្រូវបានប្រើដើម្បីបញ្ជាក់បរិបទនៃធនធាន។
- string stream_get_contents (ចំណុចទាញធនធាន [, int maxlen = -1 [, int offset = -1]])
មុខងារនេះអនុញ្ញាតឱ្យអ្នកទទួលបានមាតិកានៃស្ទ្រីមជាខ្សែអក្សរ។ ប៉ារ៉ាម៉ែត្រចំណុចទាញគឺជាធនធានខ្សែស្រឡាយ។ ប៉ារ៉ាម៉ែត្រ maxlen មាន ចំនួនអតិបរមាបៃដើម្បីអាន។ តាមលំនាំដើមវាត្រូវបានកំណត់ទៅ -1 ដែលបង្ហាញថាទិន្នន័យទាំងអស់ត្រូវបានទទួល។ ប៉ារ៉ាម៉ែត្រអុហ្វសិតមានអុហ្វសិតដែលការអានទិន្នន័យនឹងចាប់ផ្តើម។ តាមលំនាំដើមវាក៏ត្រូវបានកំណត់ទៅ -1 ដែលមានន័យថាការអាននឹងត្រូវធ្វើឡើងពីទីតាំងចាប់ផ្តើម។
ខាងក្រោមនេះជាឧទាហរណ៍នៃការទទួលទិន្នន័យក្នុងទម្រង់ JSON នៅផ្នែកខាងម៉ាស៊ីនមេ៖
// បើកចរន្តបញ្ចូលសម្រាប់ការអាន $f = fopen("php://input", "r"); // ទទួលបានមាតិកានៃស្ទ្រីម $data = stream_get_contents($f); ប្រសិនបើ ($data) ( // ដំណើរការកូដ print_r(json_decode($data)); )
រចនាសម្ព័ន្ធទិន្នន័យលទ្ធផល៖
StdClass Object ( => 2013-10-10 => 2013-10-10 => Array ( => 1 => 2 => 3 => 4 => 5 => 6 => 7))
ចំណាំ៖ វាចាំបាច់ក្នុងការគិតគូរពីការពិតដែលថាដើម្បីធ្វើការជាមួយទម្រង់ JSON ទិន្នន័យត្រូវតែត្រូវបានអ៊ិនកូដក្នុង utf-8 ។
JSON បានផ្តល់ចំនួនថេរសម្រាប់មុខងារ json_encode()
| JSON_HEX_TAG (ចំនួនគត់) | ទាំងអស់ត្រូវបានអ៊ិនកូដក្នុង \u003C និង \u003E ។ មានតាំងពី PHP 5.3.0 ។ |
| JSON_HEX_AMP (ចំនួនគត់) | ទាំងអស់ & ត្រូវបានអ៊ិនកូដក្នុង & ។ មានតាំងពី PHP 5.3.0 ។ |
| JSON_HEX_APOS (ចំនួនគត់) | តួអក្សរ ' ទាំងអស់ត្រូវបានអ៊ិនកូដក្នុង \u0027 ។ មានតាំងពី PHP 5.3.0 ។ |
| JSON_HEX_QUOT (ចំនួនគត់) | តួអក្សរ " ទាំងអស់ត្រូវបានអ៊ិនកូដក្នុង \u0022 ។ មានតាំងពី PHP 5.3.0 ។ |
| JSON_FORCE_OBJECT (ចំនួនគត់) | ត្រឡប់វត្ថុជំនួសឱ្យអារេមួយ នៅពេលប្រើអារេដែលមិនពាក់ព័ន្ធ។ វាមានប្រយោជន៍នៅពេលដែលកម្មវិធីទទួល ឬកូដរំពឹងថាមានវត្ថុ ឬអារេទទេ។ មានតាំងពី PHP 5.3.0 ។ |
| JSON_NUMERIC_CHECK (ចំនួនគត់) | ការអ៊ិនកូដខ្សែអក្សរដែលមានលេខជាលេខ។ មានតាំងពី PHP 5.3.3 ។ |
| JSON_BIGINT_AS_STRING (ចំនួនគត់) | អ៊ិនកូដចំនួនគត់ធំជាសមមូលខ្សែអក្សររបស់ពួកគេ។ មានតាំងពី PHP 5.4.0 ។ |
| JSON_PRETTY_PRINT (ចំនួនគត់) | ប្រើ តួអក្សរដកឃ្លានៅក្នុងទិន្នន័យដែលបានត្រឡប់មកវិញដើម្បីធ្វើទ្រង់ទ្រាយវា។ មានតាំងពី PHP 5.4.0 ។ |
| JSON_UNESCAPED_SLASHES (ចំនួនគត់) | កុំគេច / ។ មានតាំងពី PHP 5.4.0 ។ |
| JSON_UNESCAPED_UNICODE (ចំនួនគត់) | កុំអ៊ិនកូដពហុបៃ អក្សរយូនីកូដ(តាមលំនាំដើមពួកវាត្រូវបានអ៊ិនកូដជា \uXXXX) ។ មានតាំងពី PHP 5.4.0 ។ |
បញ្ជីនៃរបៀបដែលអាចធ្វើបានសម្រាប់ fopen() ដោយប្រើរបៀប
| 'r' | បើកឯកសារបានតែអាន; ដាក់ទ្រនិចនៅដើមឯកសារ។ |
| 'r+' | បើកឯកសារសម្រាប់អាននិងសរសេរ; ដាក់ទ្រនិចនៅដើមឯកសារ។ |
| 'w' | បើកឯកសារសម្រាប់ការសរសេរតែប៉ុណ្ណោះ; ដាក់ទ្រនិចនៅដើមឯកសារ ហើយកាត់ឯកសារទៅជាប្រវែងសូន្យ។ ប្រសិនបើឯកសារមិនមានទេ វាព្យាយាមបង្កើតវា។ |
| 'w+' | បើកឯកសារសម្រាប់អាននិងសរសេរ; ដាក់ទ្រនិចនៅដើមឯកសារ ហើយកាត់ឯកសារទៅជាប្រវែងសូន្យ។ ប្រសិនបើឯកសារមិនមានទេ វាព្យាយាមបង្កើតវា។ |
| 'a' | បើកឯកសារសម្រាប់ការសរសេរតែប៉ុណ្ណោះ; ដាក់ទ្រនិចនៅចុងបញ្ចប់នៃឯកសារ។ ប្រសិនបើឯកសារមិនមានទេ វាព្យាយាមបង្កើតវា។ |
| 'a+' | បើកឯកសារសម្រាប់អាននិងសរសេរ; ដាក់ទ្រនិចនៅចុងបញ្ចប់នៃឯកសារ។ ប្រសិនបើឯកសារមិនមានទេ វាព្យាយាមបង្កើតវា។ |
| 'x' | បង្កើត និងបើកសម្រាប់ការសរសេរតែប៉ុណ្ណោះ; ដាក់ទ្រនិចនៅដើមឯកសារ។ ប្រសិនបើឯកសារមានរួចហើយ ការហៅ fopen() នឹងបរាជ័យ ត្រឡប់ FALSE ហើយបោះកំហុស E_WARNING។ ប្រសិនបើឯកសារមិនមានទេ វានឹងព្យាយាមបង្កើតវា។ នេះគឺស្មើនឹងការបញ្ជាក់ទង់ O_EXCL|O_CREAT សម្រាប់ផ្នែកខាងក្នុង ការហៅប្រព័ន្ធបើក (2) ។ |
| 'x+' | បង្កើត និងបើកសម្រាប់ការអាន និងការសរសេរ; បើមិនដូច្នេះទេ មានឥរិយាបទដូចគ្នានឹង 'x' ។ |
| 'គ' | បើកឯកសារសម្រាប់ការសរសេរតែប៉ុណ្ណោះ។ ប្រសិនបើឯកសារមិនមានទេនោះវាត្រូវបានបង្កើត។ ប្រសិនបើឯកសារមាន នោះវាមិនត្រូវបានកាត់ឱ្យខ្លីទេ (មិនដូច 'w') ហើយការហៅមុខងារនេះមិនបណ្តាលឱ្យមានកំហុសទេ (ដូចក្នុងករណី 'x')។ ទ្រនិចឯកសារនឹងត្រូវបានកំណត់ទៅដើមឯកសារ។ វាអាចមានប្រយោជន៍ប្រសិនបើអ្នកចង់ចាក់សោឯកសារ (សូមមើល flock()) មុនពេលផ្លាស់ប្តូរវា ចាប់តាំងពីការប្រើ 'w' អាចកាត់ឯកសារមុនពេលសោត្រូវបានទទួល (ប្រសិនបើអ្នកចង់កាត់បន្ថយឯកសារ អ្នកអាចប្រើ ftruncate () មុខងារបន្ទាប់ពីការស្នើសុំសោ) ។ |
| 'c+' | បើកឯកសារសម្រាប់អាននិងសរសេរ; បើមិនដូច្នេះទេ មានឥរិយាបថដូចគ្នានឹង 'c' ។ |
សួស្តីអ្នកទាំងអស់គ្នា! នៅក្នុងអត្ថបទនេះ យើងនឹងមើលពីរបៀបផ្ញើទិន្នន័យទៅកាន់អតិថិជនក្នុងទម្រង់ JSON ក្នុង NodeJS។
សេចក្តីផ្តើមនៅក្នុងអត្ថបទចុងក្រោយ យើងបានមើលពីរបៀបផ្ញើទំព័រ HTML ទៅកាន់អតិថិជនដោយប្រើស្ទ្រីមនៅក្នុង NodeJS ។ ថ្ងៃនេះយើងនឹងមើលពីរបៀបផ្ញើទិន្នន័យក្នុងទម្រង់ JSON ។
យើងនឹងមិនប្រើខ្សែស្រឡាយដើម្បីដោះស្រាយបញ្ហានេះទេ ដូច្នេះអ្នកអាចដកកូដដែលទាក់ទងនឹងខ្សែស្រឡាយទាំងអស់។ ជំនួសមកវិញ យើងនឹងប្រើវិធីសាស្ត្រ end() ដែលធ្លាប់ស្គាល់យើងរួចហើយ ហើយត្រូវបានគេប្រើនៅក្នុងអត្ថបទមុនមួយ។
របៀបផ្ញើ JSONជាដំបូងយើងត្រូវផ្លាស់ប្តូរបឋមកថាដើម្បីឱ្យកម្មវិធីរុករកអាចដំណើរការទិន្នន័យរបស់យើងបានត្រឹមត្រូវ៖
Res.writeHead(200, ("Content-Type": "application/json"));
ឥឡូវយើងបង្កើតវត្ថុដែលយើងចង់ផ្ញើទៅអតិថិជន៖
វ៉ារ myObj = (
ឈ្មោះ៖ "ចន",
ការងារ៖ "អ្នកសរសេរកម្មវិធី",
អាយុ៖ ២៧
};
ឥឡូវយើងបញ្ជូនទិន្នន័យទៅអតិថិជន៖
Res.end(myObj);
ប៉ុន្តែតាមការពិត កូដបែបនេះនឹងមិនដំណើរការត្រឹមត្រូវទេ។ រឿងនេះគឺថាវិធីសាស្ត្រ end() រំពឹងថានឹងឃើញទិន្នន័យជាទម្រង់ខ្សែអក្សរ ឬសតិបណ្ដោះអាសន្ន។ យើងមានវត្ថុមួយ ប៉ុន្តែយើងអាចបង្កើតខ្សែចេញពីវាដូចនេះ៖
Res.end(JSON.stringify(myObj));
ឥឡូវនេះ ប្រសិនបើអ្នកដំណើរការកម្មវិធី អ្នកនឹងឃើញថាទិន្នន័យមកជាទម្រង់ JSON ជាខ្សែអក្សរ។ អ្នកក៏អាចប្រើឧបករណ៍អ្នកអភិវឌ្ឍន៍នៅក្នុងកម្មវិធីរុករករបស់អ្នក ហើយឃើញថាបឋមកថាត្រូវបានកំណត់ត្រឹមត្រូវផងដែរ។
ហេតុអ្វីបានជាផ្ញើទិន្នន័យ JSON ទៅអតិថិជនអ្នកប្រហែលជាឆ្ងល់ថាហេតុអ្វីបានជាអ្នកត្រូវផ្ញើទិន្នន័យទៅអតិថិជនក្នុងទម្រង់ JSON ទាល់តែសោះ។ ដើម្បីឆ្លើយសំណួរនេះ ស្រមៃថាអ្នកមាន javascript មួយចំនួនដែលកំពុងដំណើរការនៅលើផ្នែកអតិថិជន (frontend) ហើយវាអាចបង្កើតសំណើប្រភេទមួយចំនួន។ ឧទាហរណ៍ អ្នកមាន API ។ អ្នកអាចសរសេរសំណួរខាងក្រោម៖
Localhost: 3000/api/request
ហើយម៉ាស៊ីនមេនឹងត្រូវបញ្ជូនទិន្នន័យមកយើងសម្រាប់ការស្នើសុំនេះ។ វានឹងងាយស្រួលបំផុតក្នុងការផ្ញើពួកវាជាទម្រង់ JSON ដូច្នេះស្គ្រីបដែលដំណើរការនៅខាងអតិថិជនអាចដំណើរការទិន្នន័យនេះបានយ៉ាងងាយស្រួល។
សេចក្តីសន្និដ្ឋានដូច្នេះថ្ងៃនេះ យើងបានមើលពីរបៀបផ្ញើទិន្នន័យទៅកាន់អតិថិជនក្នុងទម្រង់ JSON ក្នុង NodeJS។
ការប្រើប្រាស់ JSON នៅផ្នែកខាងម៉ាស៊ីនមេ ដើម្បីទទួលសំណើ និងបង្កើតការឆ្លើយតប
ស៊េរីមាតិកា៖ តម្លៃពិតនៃ JSONនៅក្នុងយើងបាននិយាយអំពីរបៀបដែល JSON មានភាពងាយស្រួលជាទម្រង់ទិន្នន័យសម្រាប់កម្មវិធី Ajax ព្រោះវាអនុញ្ញាតឱ្យអ្នកបំប្លែងវត្ថុ JavaScript យ៉ាងឆាប់រហ័សទៅជាតម្លៃខ្សែអក្សរ និងច្រាសមកវិញ។ ដោយសារកម្មវិធី Ajax គឺស័ក្តិសមបំផុតសម្រាប់ការផ្ញើ និងទទួលអត្ថបទធម្មតា វាស្ទើរតែតែងតែចូលចិត្តប្រើ API ដែលអាចបង្កើតវាបាន។ JSON បន្ថែមពីលើមុខងារនេះ ក៏អនុញ្ញាតឱ្យអ្នកធ្វើការជាមួយជនជាតិដើមផងដែរ។ វត្ថុ JavaScriptហើយកុំបារម្ភអំពីរបៀបដែលវត្ថុទាំងនេះនឹងមើលទៅក្នុងអត្ថបទ។
មជ្ឈមណ្ឌលធនធាន Ajax នៅលើ developerWorks
ពិនិត្យមើលប្រភពតែមួយរបស់អ្នកសម្រាប់ការសរសេរកម្មវិធី Ajax ជាមួយនឹងអត្ថបទ ការបង្រៀន វេទិកា ប្លក់ វិគី ព្រឹត្តិការណ៍ និងព័ត៌មាន។ ប្រសិនបើមានអ្វីមួយកើតឡើងមានព័ត៌មានអំពីវា។
XML មានគុណសម្បត្តិដូចគ្នានៃទ្រង់ទ្រាយអត្ថបទដូចជា JSON ប៉ុន្តែ APIs សម្រាប់បំប្លែងវត្ថុ JavaScript ទៅជា XML (ហើយមានខ្លះ) មិនត្រូវបានអភិវឌ្ឍល្អទេបើប្រៀបធៀបទៅនឹង ចំណុចប្រទាក់កម្មវិធី JSON; នៅពេលបង្កើត និងកែប្រែវត្ថុ ពេលខ្លះអ្នកត្រូវធានាថា API ដែលបានជ្រើសរើសអាចដំណើរការជាធម្មតាជាមួយវត្ថុទាំងនេះ។ ជាមួយ JSON វាកាន់តែងាយស្រួល៖ វាគ្រប់គ្រងស្ទើរតែគ្រប់ប្រភេទនៃវត្ថុដែលអាចស្រមៃបាន ហើយគ្រាន់តែបញ្ជូនទិន្នន័យមកអ្នកវិញជាតំណាង JSON ដ៏ស្រស់ស្អាត។
ដូច្នេះ តម្លៃដ៏សំខាន់បំផុតរបស់ JSON គឺថាវាអនុញ្ញាតឱ្យអ្នកធ្វើការជាមួយ JavaScript ដូចជាមួយដែរ។ JavaScriptនិងមិនដូចភាសាធ្វើទ្រង់ទ្រាយទិន្នន័យទេ។ ដូច្នេះអ្នកអាចអនុវត្តជំនាញដែលទទួលបានទាំងអស់ក្នុងការធ្វើការជាមួយវត្ថុ JavaScript នៅក្នុងកូដរបស់អ្នកដោយមិនចាំបាច់ព្រួយបារម្ភអំពីរបៀបដែលវត្ថុទាំងនេះនឹងត្រូវបានបំប្លែងទៅជាអត្ថបទ។ អ្នកគ្រាន់តែហៅវិធីសាស្ត្រ JSON សាមញ្ញនៅចុងបញ្ចប់៖
ខ្សែអក្សរ myObjectInJSON = myObject.toJSONString();ហើយទទួលអត្ថបទដែលអាចផ្ញើទៅម៉ាស៊ីនមេ។
កំពុងបញ្ជូន JSON ទៅម៉ាស៊ីនមេមិនមានអ្វីស្មុគស្មាញជាពិសេសអំពីការផ្ញើទិន្នន័យ JSON ទៅម៉ាស៊ីនមេនោះទេ ប៉ុន្តែវាជាការពិចារណាដ៏សំខាន់ ហើយអ្នកមានជម្រើសជាច្រើនដែលត្រូវជ្រើសរើស។ ទោះជាយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកជ្រើសរើស JSON នោះវានឹងកាន់តែងាយស្រួលក្នុងការសម្រេចចិត្តបន្ថែមទៀត ដោយសារជម្រើសនឹងត្រូវបានរួមតូចយ៉ាងខ្លាំង ហើយអ្នកនឹងមិនចាំបាច់ព្រួយបារម្ភច្រើនពេកអំពីវានោះទេ។ នៅទីបញ្ចប់ អ្នកគ្រាន់តែត្រូវការបញ្ជូនខ្សែអក្សរ JSON ទៅកាន់ម៉ាស៊ីនមេ តាមចិត្តចង់លឿន និងងាយស្រួលតាមដែលអាចធ្វើទៅបាន។
ការផ្ញើ JSON ជាគូឈ្មោះ/តម្លៃ ដោយប្រើវិធីសាស្ត្រ GETមធ្យោបាយដ៏សាមញ្ញបំផុតក្នុងការបញ្ជូនទិន្នន័យ JSON ទៅម៉ាស៊ីនមេគឺដើម្បីបំប្លែងវាទៅជាអត្ថបទ ហើយផ្ញើវាជាតម្លៃនៃឈ្មោះ/តម្លៃគូ។ សូមចាំថា ទិន្នន័យដែលមានទម្រង់ JSON គឺស្អាតណាស់។ វត្ថុធំដែលមើលទៅដូចអ្វីដែលបានបង្ហាញនៅក្នុងបញ្ជី 1៖
ការចុះបញ្ជី 1. វត្ថុ JavaScript សាមញ្ញក្នុងទម្រង់ JSON var people = ( "programmers": [ ( "firstName": "Brett", "lastName":"McLaughlin", "email": " [អ៊ីមែលការពារ]" ), ( "firstName": "Jason", "lastName": "ហិនទ័រ", "អ៊ីមែល": " [អ៊ីមែលការពារ]" ), ( "firstName": "Elliotte", "lastName": "Harold", "email": " [អ៊ីមែលការពារ]" ) ], "authors": [( "firstName": "Isaac", "lastName": "Asimov", "genre": "science fiction" ), ( "firstName": "Tad", "lastName": " Williams", "genre": "fantasy"), ( "firstName": "Frank", "lastName": "Peretti", "genre": "Christian fiction") ], "musicians": [("firstName": "Eric", "lastName": "Clapton", "instrument": "guitar" ), ( "firstName": "Sergei", "lastName": "Rachmaninoff", "instrument": "piano")])ដូច្នេះអត្ថបទនេះអាចត្រូវបានផ្ញើទៅស្គ្រីបម៉ាស៊ីនបម្រើនៅក្នុងគូឈ្មោះ/តម្លៃ ដូចនេះ៖
var url = "organizePeople.php?people=" + people.toJSONString(); xmlHttp.open("GET", url, true); xmlHttp.onreadystatechange = updatePage; xmlHttp.send(null);អ្វីគ្រប់យ៉ាងហាក់ដូចជាល្អនៅទីនេះ ប៉ុន្តែតាមពិតមានការចាប់បានមួយ៖ ខ្សែទិន្នន័យ JSON របស់យើងមានចន្លោះ និងតួអក្សរផ្សេងទៀតដែលកម្មវិធីរុករកតាមអ៊ីនធឺណិតអាចព្យាយាមបកស្រាយ។ ដើម្បីការពារតួអក្សរទាំងនេះពីការបង្កបញ្ហានៅលើម៉ាស៊ីនមេ (និងរំខានដល់ការផ្ទេរទិន្នន័យ) អ្នកគួរតែបន្ថែមមុខងាររត់គេច () JavaScript ទៅកូដ។ ដូចនេះ៖
var url = "organizePeople.php?people=" + escape(people.toJSONString()); request.open("GET", url, true); request.onreadystatechange =អាប់ដេតទំព័រ; request.send(null);មុខងារនេះគ្រប់គ្រងចន្លោះ សញ្ញា និងអ្វីផ្សេងទៀតដែលអាចច្រឡំកម្មវិធីរុករក។ វាបំប្លែងពួកវាទៅជាតួអក្សរ "សុវត្ថិភាព" ក្នុងន័យនេះ (ឧទាហរណ៍ ចន្លោះមួយត្រូវបានបំប្លែងទៅជាលំដាប់រត់គេច% 20 ដែលកម្មវិធីរុករកលែងយល់ថាជាចន្លោះ ប៉ុន្តែគ្រាន់តែបញ្ជូនទៅកាន់ម៉ាស៊ីនមេមិនផ្លាស់ប្តូរ)។ បន្ទាប់មកម៉ាស៊ីនមេនឹងប្រតិបត្តិ ការបម្លែងបញ្ច្រាស(ជាធម្មតាដោយស្វ័យប្រវត្តិ) ហើយយើងនឹងទទួលបានខ្សែអក្សរដូចមុនពេលផ្ទេរ។
វិធីសាស្រ្តនេះមានគុណវិបត្តិពីរ៖
- ដំបូង យើងផ្ញើទិន្នន័យដែលអាចមានទំហំធំខ្លាំង ដោយប្រើសំណើ GET ដែលមានដែនកំណត់លើប្រវែងខ្សែអក្សរ URL ។ ទំហំបន្ទាត់អតិបរមាដែលអនុញ្ញាតគឺធំណាស់ ប៉ុន្តែយើងមិនដឹងថាចំនួនប៉ុន្មានទេ។ ខ្សែវែងយើងទទួលបានបន្ទាប់ពីការបំប្លែងវត្ថុទៅជាអត្ថបទ ជាពិសេសប្រសិនបើវត្ថុនេះស្មុគស្មាញណាស់។
- ទីពីរ យើងបញ្ជូនទិន្នន័យតាមរយៈបណ្តាញ នៅក្នុងអត្ថបទច្បាស់លាស់- នោះគឺជាវិធីសាស្រ្ដដែលមិនមានសុវត្ថិភាពបំផុតនៃការបញ្ជូនទិន្នន័យ។
ដើម្បីឱ្យច្បាស់ ចំណុចខ្វះខាតទាំងពីរនេះមានជាប់ទាក់ទងនឹងដែនកំណត់នៃសំណើរ GET ជាងចំណុចជាក់លាក់របស់ JSON ។ ទោះជាយ៉ាងណាក៏ដោយ ប្រសិនបើអ្នកផ្ញើទៅកាន់ម៉ាស៊ីនមេលើសពីនាមត្រកូល ឬនាមខ្លួនរបស់អ្នកប្រើប្រាស់ ឬលទ្ធផលនៃជម្រើសរបស់គាត់ក្នុងទម្រង់នៅលើគេហទំព័ររបស់អ្នក នោះការខ្វះខាតទាំងនេះអាចបំផ្លាញជីវិតរបស់អ្នកបានច្រើន។ ប្រសិនបើអ្នកចាប់ផ្តើមធ្វើការជាមួយទិន្នន័យដែលយ៉ាងហោចណាស់មានការសម្ងាត់ខ្លះ ឬ ទំហំធំអ្នកគួរតែយកចិត្តទុកដាក់ចំពោះសំណើ POST ។
ការផ្ទេរទិន្នន័យ JSON ដោយប្រើវិធីសាស្ត្រ POSTប្រសិនបើអ្នកសម្រេចចិត្តប្រើដើម្បីផ្ញើទិន្នន័យ JSON ទៅម៉ាស៊ីនមេ វិធីសាស្ត្រ POSTជំនួសឱ្យ GET បន្ទាប់មក ការផ្លាស់ប្តូរធំអ្នកមិនចាំបាច់បន្ថែមវាទៅលេខកូដទេ។ នេះជាអ្វីគ្រប់យ៉ាងដែលអ្នកត្រូវធ្វើ៖
var url = "organizePeople.php?timeStamp=" + new Date().getTime(); request.open("POST", url, true); request.onreadystatechange =អាប់ដេតទំព័រ; request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); request.send(people.toJSONString());ភាគច្រើននៃកូដនេះគួរតែស៊ាំពីអត្ថបទ ": ដែលបានពិភាក្សាអំពីការបង្កើតសំណើ POST ។ នៅទីនេះយើងបើកសំណើដោយប្រើ POST ជំនួសឱ្យ GET ហើយកំណត់បឋមកថា "មាតិកា-ប្រភេទ" ដែលសមស្របដើម្បីបង្ហាញពីប្រភេទនៃទិន្នន័យដែលរំពឹងទុកនៅក្នុង ក្នុងករណីនេះវានឹងមើលទៅដូចនេះ៖ application/x-www-form-urlencoded ធ្វើឱ្យវាច្បាស់ដល់ម៉ាស៊ីនមេថាយើងកំពុងឆ្លងកាត់ទិន្នន័យអត្ថបទ ដែលជាគោលការណ៍វាអាចទទួលបានពីទម្រង់ HTML ធម្មតា។
ការផ្លាស់ប្តូរតូចមួយទៀតចំពោះលេខកូដគឺការបន្ថែមទៅ URL នៃបច្ចុប្បន្នពេលវេលា។ នេះត្រូវបានធ្វើដើម្បីការពារសំណើពីការរក្សាទុកក្នុងឃ្លាំងសម្ងាត់ និងដើម្បីធានាថាពួកគេត្រូវបានបង្កើត និងផ្ញើរាល់ពេលដែលវិធីសាស្ត្រត្រូវបានហៅ។ ខ្សែអក្សរ URLនឹងខុសគ្នាបន្តិចបន្តួចរាល់ពេល ដោយសារការផ្លាស់ប្តូរត្រាពេលវេលា។ នេះគឺជាបច្ចេកទេសដែលប្រើជាទូទៅដើម្បីធានាថាសំណើ POST ពិតជាត្រូវបានបង្កើតឡើងវិញរាល់ពេល ហើយកម្មវិធីរុករកតាមអ៊ីនធឺណិតមិនព្យាយាមលាក់ការឆ្លើយតបពីម៉ាស៊ីនមេទេ។
JSON គឺគ្រាន់តែជាអត្ថបទប៉ុណ្ណោះ។នៅ ដោយប្រើ GETហើយ POST ស្នើសុំវាមានសារៈសំខាន់ខ្លាំងណាស់ដែល JSON គឺបន្ទាប់ពីទាំងអស់ អត្ថបទធម្មតា. វាអាចត្រូវបានរៀបចំ និងបញ្ជូនយ៉ាងងាយស្រួលទៅកាន់ម៉ាស៊ីនមេ ព្រោះវាមិនតម្រូវឱ្យមានការសរសេរកូដពិសេសណាមួយឡើយ។ ទិន្នន័យអត្ថបទអាចត្រូវបានដំណើរការដោយស្គ្រីបម៉ាស៊ីនមេណាមួយ។ ប្រសិនបើ JSON ជាទម្រង់គោលពីរ ឬអត្ថបទដែលបានអ៊ិនកូដយ៉ាងឆ្លាតវៃ នោះអ្វីៗនឹងមិនសាមញ្ញទេ។ ដូច្នេះ JSON គឺជាទិន្នន័យអត្ថបទធម្មតាដែលស្គ្រីបអាចទទួលបានជាគោលការណ៍នៅពេលដាក់ស្នើទម្រង់ HTML (ដូចដែលយើងបានឃើញជាមួយចំណងជើង "ប្រភេទមាតិកា" នៅក្នុងសំណើ POST) ដូច្នេះអ្នកមិនចាំបាច់ព្រួយបារម្ភច្រើនពេកអំពីវាអំពីការផ្ញើ វាទៅម៉ាស៊ីនមេ។
ការបកស្រាយ JSON នៅលើម៉ាស៊ីនមេនៅពេលដែលអ្នកបានសរសេរកូដ JavaScript ខាងអតិថិជនរបស់អ្នក ដើម្បីអនុញ្ញាតឱ្យអ្នកប្រើប្រាស់ធ្វើអន្តរកម្មជាមួយគេហទំព័រ និងទម្រង់បែបបទរបស់អ្នក ហើយមានព័ត៌មានដែលត្រូវបញ្ជូនសម្រាប់ដំណើរការ។ កម្មវិធីម៉ាស៊ីនមេអ្នកលេងសំខាន់នៅក្នុងកម្មវិធីរបស់អ្នក (ហើយប្រហែលជានៅក្នុងអ្វីទាំងអស់ដែលយើងហៅថា "កម្មវិធី Ajax" ដោយសន្មតថាការហៅទៅកាន់ស្គ្រីបម៉ាស៊ីនមេត្រូវបានធ្វើដោយអសមកាល) គឺជាម៉ាស៊ីនមេ។ ហើយនៅទីនេះ ជម្រើសដែលអ្នកបានធ្វើនៅខាងអតិថិជន ការសម្រេចចិត្តប្រើវត្ថុ JavaScript និងទិន្នន័យ JSON ត្រូវតែស្របគ្នាជាមួយនឹងការសម្រេចចិត្តដែលត្រូវគ្នានៅផ្នែកម៉ាស៊ីនមេ ដែល API សម្រាប់ការឌិកូដទិន្នន័យ JSON ត្រូវបានជ្រើសរើស។
ដំណាក់កាលពីរនៃការចាក់ JSON ទៅក្នុងម៉ាស៊ីនមេធ្វើការជាមួយ JSON នៅលើផ្នែកម៉ាស៊ីនមេ ដោយមិនគិតពីអ្វីដែលអ្នកកំពុងប្រើ ភាសាម៉ាស៊ីនមេសំខាន់មានពីរដំណាក់កាល៖
ហើយនោះជាអ្វីទាំងអស់ដែលមានចំពោះវា។ សូមក្រឡេកមើលដំណាក់កាលទាំងពីរឱ្យកាន់តែច្បាស់។
ស្វែងរកឧបករណ៍ញែក JSONធនធានដ៏ល្អបំផុតសម្រាប់ការស្វែងរកឧបករណ៍ញែក JSON និងឧបករណ៍កម្មវិធីដែលទាក់ទងនឹង JSON ផ្សេងទៀតគឺគេហទំព័រ JSON (សូមមើលតំណភ្ជាប់ក្នុង )។ បន្ថែមពីលើព័ត៌មានអប់រំអំពីទម្រង់ខ្លួនឯង នៅលើទំព័រនេះ អ្នកអាចស្វែងរកតំណភ្ជាប់ទៅកាន់ឧបករណ៍ JSON និងឧបករណ៍ញែក JSON សម្រាប់វេទិកាណាមួយ៖ ពី ASP ទៅ Erlang ពី Pike ទៅ Ruby ។ គ្រាន់តែស្វែងរកភាសាដែលស្គ្រីបរបស់អ្នកត្រូវបានសរសេរនៅទីនោះ ហើយទាញយកកញ្ចប់ឧបករណ៍សមរម្យ។ ចម្លងវាសម្រាប់ខ្លួនអ្នក ឬធ្វើបច្ចុប្បន្នភាពកំណែភាសាម៉ាស៊ីនមេរបស់អ្នកជាមួយវា ឬគ្រាន់តែដំឡើងវា (មានជម្រើសជាច្រើន៖ វាទាំងអស់គឺអាស្រ័យលើអ្វីដែលអ្នកប្រើនៅលើម៉ាស៊ីនមេ៖ C#, PHP, Lisp ឬអ្វីផ្សេងទៀត) រឿងសំខាន់គឺស្គ្រីប ឬ កម្មវិធីដែលអ្នកប្រហែលជាបានប្រើប្រអប់ឧបករណ៍នេះនៅលើម៉ាស៊ីនមេរបស់អ្នក។
ឧទាហរណ៍ ប្រសិនបើអ្នកកំពុងប្រើ PHP អ្នកអាចធ្វើបច្ចុប្បន្នភាពវាទៅកំណែ 5.2 ថ្មីៗនេះ ដែលរួមបញ្ចូលផ្នែកបន្ថែម JSON តាមលំនាំដើម។ នេះប្រហែលជាវិធីងាយស្រួលបំផុតដើម្បីចាប់ផ្តើមជាមួយ JSON ប្រសិនបើអ្នកកំពុងប្រើ PHP ។ ប្រសិនបើអ្នកកំពុងប្រើ Java servlets វិធីងាយស្រួលបំផុតគឺប្រើកញ្ចប់ org.json ពី json.org ។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវទាញយកបណ្ណសារ json.zip ពីគេហទំព័រ JSON ចម្លងឯកសារពី កូដប្រភពចូលទៅក្នុងថតចងក្រងរបស់គម្រោងរបស់អ្នក ហើយចងក្រងពួកវាតាមនោះ ហើយអ្នកនឹងអាចធ្វើការជាមួយ JSON បាន។ ប្រហែលរឿងដូចគ្នាត្រូវធ្វើនៅពេលប្រើភាសាផ្សេងទៀត; ជំនួយដ៏ល្អបំផុតនេះរួមបញ្ចូលទាំងបទពិសោធន៍សរសេរកម្មវិធីផ្ទាល់ខ្លួនរបស់អ្នកសម្រាប់វេទិកាម៉ាស៊ីនមេដែលសមស្រប។
ការប្រើប្រាស់ឧបករណ៍ញែក JSONបន្ទាប់ពីឧបករណ៍ចាំបាច់ត្រូវបានដំឡើង អ្វីទាំងអស់ដែលនៅសល់គឺត្រូវហៅទូរសព្ទ វិធីសាស្រ្តដែលចង់បាន. ឧទាហរណ៍ ឧបមាថាយើងកំពុងប្រើ PHP និងម៉ូឌុល JSON-PHP៖
// នេះគ្រាន់តែជាបំណែកនៃស្គ្រីប PHP ខាងម៉ាស៊ីនមេធំទាមទារ_once("JSON.php"); $json = សេវាកម្មថ្មី_JSON(); // ទទួលយកទិន្នន័យ POST ហើយឌិកូដវា $value = $json->decode($GLOBALS["HTTP_RAW_POST_DATA"]); // ឥឡូវនេះយើងធ្វើការជាមួយអថេរ $value ដូចនឹងទិន្នន័យ PHP "ឆៅ" ធម្មតា។ដោយប្រើកូដនេះ យើងដាក់ទិន្នន័យទាំងអស់ (អារេ ខ្សែច្រើន តម្លៃតែមួយ - អ្វីគ្រប់យ៉ាងដែលមាននៅក្នុងរចនាសម្ព័ន្ធទិន្នន័យ JSON) ទៅក្នុងអថេរ $value និងក្នុងទម្រង់ PHP ដើម។
ប្រសិនបើយើងប្រើ Java servlets និងកញ្ចប់ org.json នៅលើ server នោះកូដនឹងមើលទៅដូចនេះ៖
public void doPost(សំណើ HttpServletRequest, HttpServletResponse response) បោះ ServletException, IOException ( StringBuffer jb = new StringBuffer(); String line = null; try ( BufferedReader reader = request.getReader()); while ((line = reader.readLine != null) jb.append(line); ) catch (Exception e) ( // error message) try ( JSONObject jsonObject = new JSONObject(jb.toString()); ) catch (ParseException e) ( // គាំង និងដុត បោះ IOException ថ្មី("កំហុសក្នុងការញែកខ្សែអក្សរសំណួរ"); // យើងធ្វើការជាមួយទិន្នន័យដោយប្រើវិធីសាស្ត្រដូចជា៖ // int someInt = jsonObject.getInt("intParamName"); // String someString = jsonObject.getString("stringParamName") ; "); // JSONObject nestedObj = jsonObject.getJSONObject("nestedObjName"); // JSONArray arr = jsonObject.getJSONArray("arrayParamName"); // ហើយដូច្នេះនៅលើ... )ព័ត៌មានបន្ថែមអាចរកបាននៅក្នុងឯកសារសម្រាប់កញ្ចប់ org.json (សូមមើលតំណភ្ជាប់ក្នុងផ្នែក)។ (ចំណាំ៖ ប្រសិនបើអ្នកចង់រុករក org.json ឬកម្មវិធី JSON ផ្សេងទៀតឱ្យបានលម្អិត សូមផ្ញើអ៊ីមែលមកខ្ញុំ ហើយប្រាប់ខ្ញុំឱ្យដឹង។ មតិកែលម្អរបស់អ្នកជួយខ្ញុំក្នុងការសម្រេចចិត្តថាតើត្រូវសរសេរអ្វីបន្ទាប់!).
សេចក្តីសន្និដ្ឋានមកដល់ពេលនេះ អ្នកគួរតែដឹងហើយ។ ផ្នែកបច្ចេកទេសដោយប្រើ JSON នៅលើម៉ាស៊ីនមេ។ ប៉ុន្តែនៅក្នុងអត្ថបទនេះ និងអត្ថបទដែលខ្ញុំចង់មិនត្រឹមតែបង្ហាញមួយចំនួនប៉ុណ្ណោះទេ ទិដ្ឋភាពបច្ចេកទេសប៉ុន្តែក៏ដើម្បីបញ្ចុះបញ្ចូលអ្នកថា JSON គឺជាទម្រង់ទិន្នន័យដែលអាចបត់បែនបាន និងមានថាមពលខ្លាំង។ ទោះបីជាអ្នកមិនប្រើវានៅក្នុងគ្រប់កម្មវិធីក៏ដោយ អ្នកសរសេរកម្មវិធី Ajax និង JavaScript ដ៏ល្អគួរតែមានវានៅក្នុងដៃជានិច្ច។ ឧបករណ៍មានប្រយោជន៍និងអាចប្រើវានៅពេលមានតម្រូវការ។
ខ្ញុំពិតជាចង់ឮអំពីរបស់អ្នក។ បទពិសោធន៍ផ្ទាល់ខ្លួនធ្វើការជាមួយ JSON និងភាសាណាមួយដែលអ្នកគិតថាដំណើរការល្អ — ឬប្រហែលជាមិនល្អ — ជាមួយនឹងទិន្នន័យ JSON នៅផ្នែកខាងម៉ាស៊ីនមេ។ សូមពិនិត្យមើលទំព័រក្រុមព័ត៌មាន Java និង XML (តំណភ្ជាប់ក្នុង) ហើយប្រាប់ខ្ញុំអំពីវា។ សូមរីករាយជាមួយ JSON និងថាមពលទាំងអស់នៃទម្រង់ទិន្នន័យអត្ថបទ។
9 ចម្លើយ
ខ្ញុំទទួលបានព័ត៌មានជាច្រើននៅទីនេះ ដូច្នេះខ្ញុំចង់បង្ហោះដំណោះស្រាយដែលខ្ញុំបានរកឃើញ។
បញ្ហា៖ ការទាញយកទិន្នន័យ JSON ពី Javascript នៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិត នៅលើម៉ាស៊ីនមេ និងប្រើប្រាស់ PHP ដើម្បីញែកវាដោយជោគជ័យ។
បរិស្ថាន៖ Javascript នៅក្នុង browser (Firefox) នៅលើ Windows ។ ម៉ាស៊ីនមេ LAMP ជា ម៉ាស៊ីនមេពីចម្ងាយ៖ PHP 5.3.2 នៅលើអ៊ូប៊ុនទូ។
អ្វីដែលដំណើរការ (កំណែ 1):
1) JSON គឺគ្រាន់តែជាអត្ថបទ។ អត្ថបទក្នុងទម្រង់ជាក់លាក់មួយ ប៉ុន្តែមានតែ ខ្សែអក្សរ.
2) នៅក្នុង Javascript, var str_json = JSON.stringify(myObject) ផ្តល់ឱ្យខ្ញុំនូវខ្សែអក្សរ JSON ។
3) ខ្ញុំកំពុងប្រើវត្ថុ AJAX XMLHttpRequest ក្នុង Javascript ដើម្បីផ្ញើទិន្នន័យទៅម៉ាស៊ីនមេ៖
request= new XMLHttpRequest()
request.open("POST", "JSON_Handler.php", ពិត)
request.setRequestHeader("ប្រភេទមាតិកា", "application/json")
request.send(str_json)
[...កូដដើម្បីបង្ហាញការឆ្លើយតប...]
4) នៅលើ server PHP code ដើម្បីអាន JSON string:
$str_json = file_get_contents("php://input");
វាអានទិន្នន័យ POST ឆៅ។ $str_json ឥឡូវនេះមានខ្សែអក្សរ JSON ពិតប្រាកដពីកម្មវិធីរុករក។
អ្វីដែលដំណើរការ (កំណែ 2):
1) ប្រសិនបើខ្ញុំចង់ប្រើបឋមកថាសំណើ "application/x-www-form-urlencoded" ខ្ញុំត្រូវបង្កើត ខ្សែស្តង់ដារបង្ហោះ "x=y&a=b" ដូច្នេះនៅពេលវា។ ទទួលបាន PHPវាអាចត្រូវបានដាក់ក្នុងអារេសហការ $_POST ។ ដូច្នេះនៅក្នុង Javascript នៅក្នុងកម្មវិធីរុករក៖
Var str_json = "json_string=" + (JSON.stringify(myObject))
ឥឡូវនេះ PHP នឹងអាចបញ្ចូលអារេ $_POST នៅពេលដែលខ្ញុំផ្ញើ str_json តាមរយៈ AJAX/XMLHttpRequest ដូចនៅក្នុងកំណែ 1 ខាងលើ។
ការបង្ហាញមាតិកានៃ $_POST["json_string"] នឹងបង្ហាញខ្សែអក្សរ JSON ។ ការប្រើ json_decode() នៅលើធាតុអារេ $_POST ជាមួយខ្សែអក្សរ json នឹងឌិកូដទិន្នន័យនោះបានត្រឹមត្រូវ ហើយដាក់វាចូលទៅក្នុងអារេ/វត្ថុ។
ឧបាយកលដែលខ្ញុំបានជួបប្រទះ៖
ដំបូងឡើយ ខ្ញុំបានព្យាយាមផ្ញើខ្សែអក្សរ JSON ជាមួយនឹងបឋមកថាកម្មវិធី /x -www-form-urlencoded ហើយបន្ទាប់មកព្យាយាមអានវាភ្លាមៗពីអារេ $_POST ក្នុង PHP ។ អារេ $_POST តែងតែទទេ។ នេះគឺដោយសារតែវារំពឹងថាទិន្នន័យនៃទម្រង់ yval = xval & . វាមិនបានរកឃើញទិន្នន័យបែបនេះទេ គ្រាន់តែជាខ្សែអក្សរ JSON ហើយវាគ្រាន់តែបោះវាចោល។ ខ្ញុំបានមើលក្បាលសំណើ ហើយទិន្នន័យ POST ត្រូវបានផ្ញើយ៉ាងត្រឹមត្រូវ។
ដូចគ្នានេះដែរ ប្រសិនបើខ្ញុំប្រើបឋមកថាកម្មវិធី/json ម្តងទៀត ខ្ញុំមិនអាចចូលប្រើទិន្នន័យដែលត្រូវបានផ្ញើតាមរយៈអារេ $_POST បានទេ។ ប្រសិនបើអ្នកចង់ប្រើបឋមកថាមាតិកាកម្មវិធី / json នោះអ្នកត្រូវចូលប្រើឆៅ បង្ហោះទិន្នន័យនៅក្នុង PHP តាមរយៈ ការបញ្ចូល php// មិនមែនជាមួយ $_POST ទេ។
អក្សរសិល្ប៍៖
1) របៀបចូលប្រើទិន្នន័យ POST ក្នុង PHP: របៀបចូលប្រើទិន្នន័យ POST ក្នុង PHP?
2) ពត៌មានលំអិតអំពីប្រភេទកម្មវិធី/json ជាមួយនឹងវត្ថុគំរូមួយចំនួនដែលអាចបំប្លែងទៅជាខ្សែអក្សរ JSON ហើយផ្ញើទៅកាន់ម៉ាស៊ីនមេ៖ http://www.ietf.org/rfc/rfc4627.txt< ш >
ឯកសារ Javascriptដោយប្រើ jQuery (ស្អាតជាងប៉ុន្តែបណ្ណាល័យលើស):
$.ajax((ប្រភេទ៖ "POST", url: "process.php", data: (json: JSON.stringify(json_data)), dataType: "json" ));
ឯកសារ PHP (process.php)៖
ទិសដៅ = json_decode($_POST["json"]); var_dump (ទិសដៅ);
សូមចំណាំថា ប្រសិនបើអ្នកកំពុងប្រើមុខងារ callback នៅក្នុង javascript របស់អ្នក៖
$.ajax((ប្រភេទ៖ "POST", url: "process.php", ទិន្នន័យ៖ (json: JSON.stringify(json_data)), dataType: "json" )) .done(function(data) ( console.log ("រួចរាល់"); console.log(ទិន្នន័យ)).fail(function(data)( console.log("fail"); console.log(data); ));
អ្នកត្រូវតែនៅក្នុងឯកសារ PHP របស់អ្នកត្រឡប់វត្ថុ JSON (ក្នុងទម្រង់ javascript) ដើម្បីទទួលបានលទ្ធផល "done/success" នៅក្នុងរបស់អ្នក កូដ Javascript. ជាមួយនឹងការត្រឡប់មកវិញ / បោះពុម្ពអប្បបរមា:
បោះពុម្ព ("()");
ទោះបីជាសម្រាប់អ្វីដែលធ្ងន់ធ្ងរជាងនេះ អ្នកគួរតែផ្ញើយ៉ាងច្បាស់លាស់ ចំណងជើងត្រឹមត្រូវ។ជាមួយនឹងលេខកូដឆ្លើយតបដែលត្រូវគ្នា។
មានវិធីពាក់ព័ន្ធចំនួន 3 ដើម្បីផ្ញើទិន្នន័យពីខាងអតិថិជន (HTML, Javascript, Vbscript..etc) ទៅ ផ្នែកខាងម៉ាស៊ីនមេ(PHP, ASP, JSP ... ល។ )
1. ទម្រង់ HTMLការស្នើសុំប្រកាស (ទទួល ឬ ប្រកាស) ។ 2. AJAX (នេះក៏មាននៅក្រោម GET និង POST) 3. Cookie
ទម្រង់ស្នើសុំប្រកាស HTML (ទទួល ឬប្រកាស)
នេះជាវិធីសាស្ត្រដែលប្រើញឹកញាប់បំផុត ហើយយើងអាចផ្ញើទិន្នន័យបន្ថែមទៀតដោយប្រើវិធីសាស្ត្រនេះ។
នេះគឺជាវិធីសាស្ត្រអសមកាល ហើយវាគួរតែដំណើរការ តាមរបៀបសុវត្ថិភាពនៅទីនេះ យើងក៏អាចផ្ញើទិន្នន័យបន្ថែមទៀតផងដែរ។
នេះ។ វិធីល្អ។ប្រើចំនួនតូចមួយនៃទិន្នន័យមិនរសើប។ នេះ។ មធ្យោបាយល្អបំផុតធ្វើការជាមួយប៊ីតទិន្នន័យ។
ក្នុងករណីរបស់អ្នក អ្នកអាចចូលចិត្តការបញ្ជូនទម្រង់ HTML ឬ AJAX ។ ប៉ុន្តែមុនពេលផ្ញើទៅកាន់ម៉ាស៊ីនមេ សូមធ្វើសុពលភាព json របស់អ្នកដោយខ្លួនឯង ឬប្រើតំណភ្ជាប់ដូចជា http://jsonlint.com/
ប្រសិនបើ Json Object បំប្លែងវាទៅជា String ដោយប្រើ JSON.stringify(object) ប្រសិនបើអ្នកមាន JSON string សូមផ្ញើវាដូចដែល។
ឧទាហរណ៍ JavaScript សាមញ្ញសម្រាប់ការបញ្ចូលវាល HTML (ផ្ញើ JSON ទៅម៉ាស៊ីនមេ ញែក JSON ក្នុង PHP និងផ្ញើត្រឡប់ទៅម៉ាស៊ីនភ្ញៀវវិញ) ដោយប្រើ AJAX៖
នាមត្រកូល
អាយុ
បង្ហាញ var xmlhttp; function actionSend() (ប្រសិនបើ (window.XMLHttpRequest) (// កូដសម្រាប់ IE7+, Firefox, Chrome, Opera, Safari xmlhttp = new XMLHttpRequest(); ) else (// កូដសម្រាប់ IE6, IE5 xmlhttp = new ActiveXObject("Microsoft.XMLHTTP"); ) var values = $("input").map(function() ( return $(this).val() ; ) ) ទទួលបាន (); var myJsonString = JSON.stringify(តម្លៃ); xmlhttp.onreadystatechange = ឆ្លើយតប; xmlhttp.open("POST", "ajax-test.php", ពិត); xmlhttp.send(myJsonString); ) មុខងារឆ្លើយតប() (ប្រសិនបើ (xmlhttp.readyState == 4 && xmlhttp.status == 200) ( document.getElementById("លទ្ធផល").innerHTML = xmlhttp.responseText; ) )
ឯកសារ PHP ajax-test.php៖
