การทำให้เป็นอนุกรม PHP กับ JSON

ลิงค์ต้นฉบับ: http://hi.baidu.com/lostdays/blog/item/8d76c300ec4e3c15738b65fa.html

แคตตาล็อกทั่วไป

อะไร ทำไม

อย่างไร
ทำไม
วิธี

ไวยากรณ์การทำให้เป็นอนุกรมของ PHP
ตัวอย่างการทำให้เป็นอนุกรม PHP
ทำให้เป็นอนุกรมเป็น JSON ใน JavaScript — โดยใช้ json2.js
ทำให้เป็นอนุกรมเป็น JSON ใน JavaScript โดยใช้ Prototype.js

PHP พร้อมด้วยฟังก์ชัน JSON

json_decode
ฟังก์ชัน json_encode
ตัวอย่างฟังก์ชัน json_decode
ตัวอย่างการฝึกฝนฟังก์ชัน json_encode

ให้

คำอธิบายพื้นฐานความรู้

ส่วนส่วนหน้า JavaScript
ส่วนแบ็กเอนด์ PHP

อะไร ทำไม อย่างไร

โอเค

เพื่อน ๆ ที่รัก เรามาเริ่มต้นการเดินทางของแนวคิดใหม่นี้กันดีกว่า บางทีทุกคนอาจไม่ได้ให้ความสนใจกับหัวข้อเรื่องซีเรียลไลซ์มาก่อนเลย และเจอซีเรียลไลซ์นี้ หลังจากนั้นฉันก็เบื่อและทำปลั๊กอิน WordPress ขึ้นมา ตอนนี้ฉันใช้ซีเรียลไลซ์และพบว่ามันสะดวกมากจริงๆ ในบางสถานการณ์

ก่อนอื่นมาอธิบายการทำให้เป็นอนุกรมกันก่อน: พูดง่ายๆ ก็คือการทำให้เป็นอนุกรมเป็นกระบวนการแปลงตัวแปรให้เป็นสตรีมไบต์ การแนะนำการทำให้เป็นอนุกรมช่วยแก้ปัญหาการจัดเก็บและการส่งข้อมูลออบเจ็กต์ได้อย่างมีประสิทธิภาพ ตัวอย่างเช่น ฉันสร้างออบเจ็กต์ใน JavaScript และตอนนี้ฉันต้องการบันทึกออบเจ็กต์นี้ลงในฐานข้อมูลฝั่งเซิร์ฟเวอร์ ของวัตถุต่างๆ มักจะถูกนำมาใช้ ในการทำให้เป็นอนุกรมของ JavaScript เราต้องพูดถึง JSON JSON (JavaScript Object Notation) เป็นรูปแบบการแลกเปลี่ยนข้อมูลที่มีน้ำหนักเบา ง่ายสำหรับมนุษย์ในการอ่านและเขียน และง่ายสำหรับเครื่องจักรในการแยกวิเคราะห์และสร้าง ขึ้นอยู่กับภาษาการเขียนโปรแกรม JavaScript ซึ่งเป็นชุดย่อยของ Standard ECMA-262 ฉบับที่ 3 - ธันวาคม 1999 JSON ใช้รูปแบบข้อความที่ไม่ขึ้นอยู่กับภาษาโดยสมบูรณ์ แต่ยังใช้รูปแบบที่คล้ายกับตระกูลภาษา C (รวมถึง C, C++, C#, Java, JavaScript, Perl, Python ฯลฯ) คุณสมบัติเหล่านี้ทำให้ JSON เป็นภาษาการแลกเปลี่ยนข้อมูลในอุดมคติ

ผู้คนมักจะเปรียบเทียบ JSON และ XML ทั้งสองเป็นวิธีการทำให้วัตถุแบน (เราจะอธิบาย "การทำให้แบน" นี้ในภายหลัง) XML มีลักษณะเฉพาะด้วยโครงสร้างที่เข้มงวด ในขณะที่ JSON มีลักษณะเฉพาะคือเรียบง่ายและอ่านง่าย โปรแกรมสำหรับการวิเคราะห์ เนื่องจากสามารถแปลงวัตถุเป็นรูปแบบสตรีมอักขระได้อย่างง่ายดาย เช่น รหัสต่อไปนี้:

รหัส:

{"type": "มนุษย์" "ชื่อ": "hanguofeng" "อายุ": 22 }

เป็นนิพจน์ JSON ที่บันทึกวัตถุ เราจะคืนค่าวัตถุนั้นได้อย่างไร ง่ายมาก ดังนี้:

รหัส:

var animal_str = '{"type///human","name://hanguofeng","age":22}';
var animal2=eval('(' + animal_str + ')');

เราใช้ฟังก์ชันการประเมินผล JavaScript เพื่อดำเนินการนิพจน์ JSON และคืนค่าเพื่อให้ได้วัตถุ ณ จุดนี้ ฉันคิดว่าคุณจะเข้าใจอย่างแน่นอน เช่นเดียวกับฉัน ชื่นชมความคิดของผู้สร้างรูปแบบ JSON ตอนแรกฉันจะพูดถึงเรื่องซีเรียลไลซ์ แต่ฉัน "บังเอิญ" พูดถึง JSON และพูดถึงมันมาก ฮ่าๆ ฉันผิดประเด็นไปหรือเปล่า? ไม่ การทำให้เป็นอนุกรมของ PHP นั้นคล้ายคลึงกับ JSON มาก นิพจน์การทำให้เป็นอนุกรมของ PHP เป็นดังนี้:

รหัส:
a:3:{s:4:"type";s:5:"มนุษย์";s:4:"ชื่อ";s:10:"hanguofeng";s:3:"อายุ";s:2:" 20";}
โครงสร้างของมันดูค่อนข้างคล้ายกับ JSON อันที่จริง นิพจน์นี้เป็นผลลัพธ์แบบอนุกรมของอาร์เรย์ต่อไปนี้:
รหัส:
$สัตว์=
อาร์เรย์
-
"type" => "มนุษย์",
"name" => "hanguofeng",
"อายุ" => "20"
-
ตกลง การแนะนำข้างต้นเป็นเพียงเพื่อให้คุณเข้าใจคร่าวๆ ว่าการทำให้เป็นอนุกรมและ JSON คืออะไร คุณไม่จำเป็นต้องเข้าไปพัวพันกับโค้ดมากเกินไปที่นี่ เราจะอธิบายรายละเอียดในภายหลัง ใช้การเปลี่ยนลำดับ

เหตุใด

การทำให้เป็นอนุกรมจึงปรากฏเพื่อความสะดวกในการส่งข้อมูล เมื่อฉันถามคำถามในตอนต้นของบทความนี้ ฉันจึงสร้างออบเจ็กต์ใน JavaScript ตอนนี้ฉันต้องการบันทึกออบเจ็กต์นี้ลงในฐานข้อมูลฝั่งเซิร์ฟเวอร์ ในความเป็นจริง มันเป็นคำถามที่ว่า "ฉันจะส่งออบเจ็กต์จากเบราว์เซอร์ไปยังเซิร์ฟเวอร์ได้อย่างไร" ในระหว่างกระบวนการส่งข้อมูลนี้ เรารู้ว่ามีเพียงสตรีมอักขระเท่านั้นที่สามารถส่งได้จริง สตรีมอักขระเป็นแบบมิติเดียว (แบน) แต่วัตถุจำนวนมาก แต่มันมีหลายมิติ หากวัตถุที่จะถ่ายโอนเป็นสตริงก็ง่ายมาก เราสามารถใช้เป็นเนื้อหาที่ถ่ายโอนได้โดยตรง จำเป็นต้องใช้ตัวอักษร ในการอธิบายเขา เช่น ทางโทรศัพท์ ถ้าฉันถามคุณว่าคุณชื่ออะไร คุณจะบอกฉันว่าคุณชื่อจางซานหรือหลี่ซือ และถ้าฉันถามคุณ คุณหน้าตาเป็นอย่างไร คุณต้องใช้คำพูด ฉันอธิบายไว้ว่าสื่อที่เราส่งข้อมูลมักจะเหมือนกับสายโทรศัพท์นี้ซึ่งสามารถส่งกระแสข้อมูลอักขระได้เท่านั้น และกระบวนการที่เราอธิบายวัตถุนั้นเป็นกระบวนการของการซีเรียลไลซ์ .

นอกจากนี้ การทำให้เป็นอนุกรมยังสามารถใช้สำหรับการจัดเก็บอ็อบเจ็กต์แบบถาวร เช่นเดียวกับฉัน บางทีคุณอาจเคยคิดที่จะจัดเก็บอ็อบเจ็กต์ในฟิลด์ใดฟิลด์หนึ่งของฐานข้อมูล ตอนนี้เราสามารถทำได้อย่างง่ายดาย และฟิลด์ฐานข้อมูลของคุณไม่ต้องการแล้ว หากต้องการตั้งค่าเป็นรูปแบบพิเศษ เพียงตั้งค่าเป็น varchar (แน่นอน หากวัตถุมีขนาดใหญ่ คุณอาจต้องตั้งค่าเป็นข้อความ)

วิธี

ไวยากรณ์การทำให้เป็นอนุกรมของ PHP

โอเค ฉันคิดว่าคุณเข้าใจคำถามของอะไรและทำไมแล้ว ในตอนท้ายของส่วนนี้ เราจะพูดถึงบางสิ่งที่เป็นเชิงทฤษฎีมากกว่า นั่นคือ วิธีใช้ PHP เพื่อทำให้ข้อมูลเป็นอนุกรมและดีซีเรียลไลซ์ วิธีทำให้เป็นอนุกรม JavaScript อ็อบเจ็กต์ (นั่นคือ เปลี่ยนเป็นรูปแบบ JSON) และวิธีดีซีเรียลไลซ์วัตถุเหล่านั้น สุดท้ายคือวิธีสร้างความสัมพันธ์ระหว่างการทำให้เป็นอนุกรมของ JSON และ PHP

PHP มีฟังก์ชันสองอย่างสำหรับการดำเนินการซีเรียลไลซ์และดีซีเรียลไลซ์ ฟังก์ชันทั้งสองนี้ได้แก่: serialize() และ unserialize() ซึ่งเหมาะสำหรับ PHP4 และ PHP5 โดยมีคำอธิบายไว้ด้านล่าง:

serialize()

(PHP 4, PHP 5, PECL axis2 :0.1.0-0.1.1)
ทำให้เป็นอนุกรม - รับสตริงค่าการแสดงที่จัดเก็บได้

ทำให้

เป็นอนุกรม (ผสม $value)
รับค่าการแสดงที่จัดเก็บได้ ฟังก์ชันนี้ใช้เพื่อจัดเก็บหรือถ่ายโอนค่าตัวแปรและโครงสร้าง PHP โดยไม่สูญเสียข้อมูล
หากคุณต้องการแปลงค่าซีเรียลไลซ์กลับเป็นตัวแปร PHP คุณสามารถใช้ฟังก์ชัน unserialize() ได้

ค่า

พารามิเตอร์

นั่นคือนิพจน์ที่กำลังถูกทำให้เป็นอนุกรม serialize() จัดการทุกประเภทยกเว้นตัวชี้ทรัพยากร และคุณยังสามารถทำให้อนุกรมอาร์เรย์ที่มีองค์ประกอบที่ชี้ไปที่ตัวมันเองได้ อาร์เรย์หรือออบเจ็กต์ที่คุณทำให้เป็นอนุกรมซึ่งมีตัวชี้แบบวนซ้ำจะยังคงถูกจัดเก็บ แต่ตัวชี้อื่นๆ จะหายไป
เมื่อทำให้วัตถุเป็นอนุกรม PHP จะพยายามเรียกใช้ฟังก์ชันสมาชิกก่อน __sleep() สิ่งนี้จะช่วยให้ทำสิ่งต่าง ๆ เช่นการล้างข้อมูลครั้งสุดท้ายก่อนที่วัตถุจะถูกทำให้เป็นอนุกรม ในทำนองเดียวกัน เมื่อวัตถุถูกกู้คืนโดยใช้ฟังก์ชัน unserialize() ฟังก์ชันสมาชิก __wakeup() จะถูกเรียก

ค่าที่ส่งคืน

จะส่งกลับสตริงที่มีนิพจน์สตรีมไบต์ของออบเจ็กต์ที่สามารถจัดเก็บได้ทุกที่

ยกเลิกการซีเรียลไลซ์()

(PHP 4, PHP 5, PECL axis2:0.1.0-0.1.1)

รับ

ค่าตัวแปร PHP จากนิพจน์ที่เก็บไว้

แบบผสม unserialize ( string $str )
unserialize() ใช้ตัวแปรซีเรียลไลซ์ประเภทธรรมดาแล้วแปลงกลับเป็นค่าตัวแปร PHP

พารามิเตอร์

str

สตริงซีเรียลไลซ์ หากตัวแปรดีซีเรียลไลซ์เป็นอ็อบเจ็กต์ หลังจากกู้คืนโครงสร้างของอ็อบเจ็กต์ได้สำเร็จ PHP จะพยายามรันฟังก์ชันสมาชิก __wakeup() ของอ็อบเจ็กต์โดยอัตโนมัติ (ถ้ามี)
คำสั่ง unserialize_callback_func: คุณสามารถตั้งค่าฟังก์ชันการเรียกกลับที่จะดำเนินการในระหว่างกระบวนการนี้ได้ หากคลาสที่ไม่ได้กำหนดควรถูกสร้างอินสแตนซ์ในระหว่างการดีซีเรียลไลซ์ (เพื่อหลีกเลี่ยงการรับอ็อบเจ็กต์ที่ไม่สมบูรณ์ "__PHP_Incomplete_Class") คุณสามารถใช้ php.ini, ini_set() หรือ .htaccess เพื่อกำหนด "unserialize_callback_func" มันถูกเรียกเมื่อมีการสร้างอินสแตนซ์คลาสที่ไม่ได้กำหนด หากต้องการปิดใช้งานคุณลักษณะนี้ เพียงตั้งค่าให้ว่างเปล่า

ค่าที่ส่งกลับ

จะส่งกลับค่าที่แปลงแล้ว ซึ่งอาจเป็นตัวแปรบูลีน จำนวนจริง หมายเลขทศนิยม สตริง อาร์เรย์ หรืออ็อบเจ็กต์
ถ้าสตริงขาเข้าไม่สามารถดีซีเรียลไลซ์ได้ FALSE จะถูกส่งกลับและข้อผิดพลาด NOTICE จะถูกส่งออกไป
(ข้อความข้างต้นแปลจากคู่มือ PHP)

การทำให้เป็นอนุกรมและดีซีเรียลไลซ์ของ

อาร์เรย์อินสแตนซ์ PHP

ตกลง ให้เราเรียนรู้ด้วยตัวอย่าง ขั้นแรก โปรดสร้างไฟล์ Sample1.php เราใช้คำสั่งต่อไปนี้ในไฟล์นี้ อาร์เรย์:

รหัส:
<?php
$สัตว์=
อาร์เรย์
-
"type" => "มนุษย์",
"name" => "hanguofeng",
"อายุ" => "20"
-
-
เพื่อทดสอบค่าของอาร์เรย์นี้ คุณสามารถใช้ฟังก์ชัน print_r() เพื่อส่งออกอาร์เรย์ได้ผลลัพธ์ดังนี้:

รหัส:
อาร์เรย์
-
[ประเภท] => มนุษย์
[ชื่อ] => ฮั่นกั๋วเฟิง
[อายุ] => 20
-
จากนั้นมาทำให้เป็นอนุกรมกัน รหัสซีเรียลไลซ์เป็นดังนี้:

รหัส:
<?php
$สัตว์=
อาร์เรย์
-
"type" => "มนุษย์",
"name" => "hanguofeng",
"อายุ" => "20"
-
$animal_ser=ซีเรียลไลซ์($สัตว์);
เสียงสะท้อน($animal_ser);
-
ที่นี่เราซีเรียลไลซ์อาร์เรย์ $animal บันทึกสตริงซีเรียลไลซ์ที่ส่งคืนในตัวแปร $animal_ser และส่งออกผลลัพธ์คือ:

รหัส:
a:3:{s:4:"type";s:5:"มนุษย์";s:4:"ชื่อ";s:10:"hanguofeng";s:3:"อายุ";s:2:" 20";}
ลองแยกวิเคราะห์สตริงนี้:
a:3 บ่งชี้ว่านี่คือวัตถุอาร์เรย์ (a) ซึ่งมีวัตถุในตัวสามตัว (3)
ส่วนที่อยู่ภายในเครื่องหมายปีกกาคือรายการนิพจน์อ็อบเจ็กต์ที่คั่นด้วยเครื่องหมายจุลภาค โดยใช้ s:4:"type" เป็นตัวอย่าง โดยจะแสดงสตริงที่มีความยาว 4 หลัก (4) และค่าเป็น "type" นั่นคือกุญแจสำคัญขององค์ประกอบแรกของอาร์เรย์แฮช
เราจะไม่ลงรายละเอียดในส่วนต่อไปนี้ คุณสามารถลองซีเรียลไลซ์อ็อบเจ็กต์ต่างๆ ได้ด้วยตัวเอง และดูว่าสตริงซีเรียลไลซ์ถูกสร้างขึ้นอย่างไร
ลองดูที่การดีซีเรียลไลซ์ของอาเรย์ นั่นคือ การเรียกคืนสตริงซีเรียลไลซ์ที่เราสร้างไว้ด้านบนให้เป็นอาเรย์ รหัสจะเป็นดังนี้:

รหัส:
<?php
$animal_ser='a:3:{s:4:"type";s:5:"human";s:4:"name";s:10:"hanguofeng";s:3:"อายุ";s :2:"20";}';
$animal = ยกเลิกการซีเรียลไลซ์($animal_ser);
print_r($สัตว์);
-
ในบรรทัดแรก เราถือว่าค่าของ $animal_ser เป็นสตริงซีเรียลไลซ์ที่ได้รับด้านบน ในบรรทัดที่สอง สตริงจะถูกกู้คืนไปยังอาร์เรย์เริ่มต้นและกำหนดให้กับ $animal ในที่สุด อาร์เรย์ $animal จะถูกส่งออก เวลา เอาต์พุตเหมือนกับเอาต์พุตอาเรย์ดั้งเดิมที่จุดเริ่มต้นของส่วนนี้ นั่นคือ:

รหัส:
อาร์เรย์
-
[ประเภท] => มนุษย์
[ชื่อ] => ฮั่นกั๋วเฟิง
[อายุ] => 20
-
ด้วยวิธีนี้เราได้เสร็จสิ้นการดีซีเรียลไลเซชันของอาเรย์แล้ว

ขยายความรู้ - การทำให้เป็นอนุกรมและดีซีเรียลไลซ์ของออบเจ็กต์แบบกำหนดเอง

การซีเรียลไลซ์อาร์เรย์เป็นการดำเนินการพื้นฐาน อย่างไรก็ตาม ในการเขียนโปรแกรมจริง เราอาจทำให้ซีเรียลไลซ์ตัวแปรประเภทอื่น ๆ บ่อยครั้ง เช่น ออบเจ็กต์แบบกำหนดเองจะถูกทำให้เป็นอนุกรม นี่คือคลาส A ที่เขียนด้วยตัวเอง (บันทึกไว้ใน classa .inc):

รหัส:
<?php
คลาสเอ {
วาร์ $หนึ่ง = 1;
ฟังก์ชั่น show_one() {
สะท้อน $this->หนึ่ง;
-
-
-
เราสร้างอินสแตนซ์ของคลาสและทำให้อินสแตนซ์เป็นอนุกรมในรหัสต่อไปนี้:

รหัส:
<?php
รวม("classa.inc");
$a=กใหม่;
echo(ทำให้เป็นอนุกรม($a));
-
เนื้อหาที่ส่งออกในขณะนี้คือ:

รหัส:
O:1:"ก":1:{s:3:"หนึ่ง";i:1;}
โดยรวมแล้ว สตริงที่ซีเรียลไลซ์นี้จะส่งออกสถานะปัจจุบันของอ็อบเจ็กต์ กล่าวคือ ค่าของ i คือ 1 มาวิเคราะห์รายละเอียดทีละรายการกัน O:1: เนื่องจากตัวแปรปัจจุบันเป็นออบเจ็กต์แบบกำหนดเอง อักขระกำหนดลักษณะจึงเป็น "O" ซึ่งหมายถึงออบเจ็กต์ "A" ต่อไปนี้จะระบุว่าคลาสใดที่เป็นอินสแตนซ์ของตัวแปร ในที่นี้คือคลาส A ภายในวงเล็บปีกกาคือชื่อและค่าของแต่ละแอตทริบิวต์ของอินสแตนซ์ จากนั้นเราก็ทำการดีซีเรียลไลซ์มัน:

รหัส:
<?php
รวม("classa.inc");
$s = 'O:1:"A":1:{s:3:"one";i:1;}';
$a = ยกเลิกการซีเรียลไลซ์($s);
$a->show_one();
-
ในเวลานี้เอาต์พุต "1" นั่นคือเรียกว่าเมธอด show_one() ของคลาส A คุณจะสังเกตได้ว่าแม้ว่าสตริงที่ซีเรียลไลซ์ของอินสแตนซ์จะไม่มีเมธอดคลาส แต่เรายังคงสามารถเรียกเมธอดคลาสได้หลังจากที่เราดีซีเรียลไลซ์แล้ว คุณลักษณะนี้รองรับใน PHP4 ขึ้นไป (แน่นอนว่า คุณต้องรวมไฟล์คำจำกัดความของคลาสด้วย classa.inc)

หมายเหตุ: คุณสามารถอ้างถึงส่วน การอ้างอิงภาษา -> คลาสและออบเจ็กต์ -> ออบเจ็กต์การทำให้เป็นอนุกรม - ออบเจ็กต์ในเซสชันของคู่มือ PHP

การทำให้เป็นอนุกรมเป็น JSON ใน JavaScript โดยใช้ json2.js

ไม่มีวิธีการในตัวในการทำให้วัตถุเป็นอนุกรมโดยตรงใน JavaScript แน่นอนว่าคุณสามารถเขียนได้ด้วยตัวเอง แต่ฉันยังคงแนะนำอย่างยิ่งให้คุณขี้เกียจที่นี่และใช้ส่วนประกอบสำเร็จรูป เว็บไซต์อย่างเป็นทางการ www.json.org มีไลบรารีโค้ดสำหรับการทำให้วัตถุ JavaScript เป็นอนุกรม JSON - json2.js ซึ่งคุณสามารถรับได้จากที่นี่

หลังจากได้รับไฟล์ json2.js แล้ว คุณสามารถเปิดไฟล์นี้ได้ ส่วนแรกของไฟล์ประกอบด้วยข้อมูลความคิดเห็นจำนวนมาก หากภาษาอังกฤษของคุณดีพอ คุณสามารถละเว้นส่วนนี้และอ้างอิงถึงความคิดเห็นของไฟล์ได้ โอเค ถ้าในฐานะโปรแกรมเมอร์ คุณเห็นตัวอักษรมามากพอแล้ว และอยากเห็นตัวอักษรจีน + ตัวอักษรของฉัน ก็ลงไปต่อได้เลย

เพียงแปลความคิดเห็นนี้: โปรดดูที่ http://www.JSON.org/js.html ไฟล์นี้สร้างอ็อบเจ็กต์สากล JSON ซึ่งมีวิธีการสองวิธีคือ:

รหัส:
JSON.stringify(ค่า, ไวท์ลิสต์)
ให้คุณค่ากับค่า JavaScript ใดๆ ซึ่งโดยปกติจะเป็นออบเจ็กต์หรืออาร์เรย์
รายการที่อนุญาต พารามิเตอร์อาร์เรย์ทางเลือกที่ใช้เพื่อกำหนดวิธีทำให้ค่าอ็อบเจ็กต์เป็นอนุกรม เมธอดนี้สร้างข้อความ JSON จากค่า JavaScript เมื่อทำให้เป็นซีเรียลไลซ์ มีความเป็นไปได้สามประการตามรายการพารามิเตอร์ที่อนุญาตพิเศษ:
หากวัตถุมีเมธอด toJSON ให้เรียกเมธอดนี้แล้วค่าที่ส่งคืนของเมธอด toJSON จะถูกทำให้เป็นอนุกรม
มิฉะนั้น หากพารามิเตอร์รายการที่อนุญาตพิเศษคืออาร์เรย์ องค์ประกอบในอาร์เรย์จะถูกใช้เพื่อเลือกสมาชิกของออบเจ็กต์สำหรับการทำให้เป็นอนุกรม
มิฉะนั้น หากไม่ได้ใช้พารามิเตอร์ whitelist สมาชิกทั้งหมดของออบเจ็กต์จะถูกทำให้เป็นอนุกรม
หากค่าไม่มีการแทนค่า JSON เช่น ไม่ได้กำหนดหรือฟังก์ชัน ค่านั้นจะไม่ถูกทำให้เป็นอนุกรม ในวัตถุค่าดังกล่าวจะถูกละเว้นและในอาร์เรย์จะถูกแทนที่ด้วยค่าว่าง
JSON.stringify(unknown) จะกลับมาไม่ได้กำหนด วันที่จะถูกเรียงลำดับตามวันที่ ISO ที่เสนอราคา
ตัวอย่าง:

รหัส:
ข้อความ var = JSON.stringify(['e', {pluribus: 'unum'}]);
//ข้อความคือ '["e",{"pluribus///unum"}]'
JSON.parse(ข้อความ, ตัวกรอง)
วิธีนี้จะแยกวิเคราะห์ข้อความ JSON และสร้างส่วนประกอบหรืออาร์เรย์ ซึ่งอาจทำให้เกิดข้อยกเว้น SyntaxError
พารามิเตอร์ตัวกรองเพิ่มเติมคือฟังก์ชันที่กรองและแปลงผลลัพธ์ โดยยอมรับแต่ละคีย์และค่า และใช้ค่าที่ส่งคืนเพื่อแทนที่ค่าต้นฉบับ หากส่งคืนค่าที่ได้รับ ผลลัพธ์จะไม่เปลี่ยนแปลง หากส่งคืนไม่ได้กำหนด สมาชิกจะถูกลบ
ตัวอย่าง:

รหัส:
//แยกวิเคราะห์ข้อความและหากคีย์มีสตริง "date" ให้แปลงค่าเป็นวันที่
myData = JSON.parse (ข้อความ, ฟังก์ชั่น (คีย์, ค่า) {
return key.indexOf('date') >= 0 ? new Date(value) : value;
-
บทช่วยสอนเบื้องต้นข้างต้นทำให้คุณมีความเข้าใจพื้นฐานเกี่ยวกับวิธีใช้ json2.js ฉันจะไม่ลงรายละเอียดเกี่ยวกับไฟล์นี้ ฉันแค่มีเคล็ดลับเล็กๆ น้อยๆ หากคุณต้องการแยกวิเคราะห์ข้อความ JSON คุณสามารถใช้ eval ได้ () ฟังก์ชัน ฟังก์ชันนี้เป็นฟังก์ชันในตัวของ JavaScript ตัวอย่างเช่น หากต้องการแยกวิเคราะห์ข้อความ JSON ที่สร้างขึ้นในกรณีของ JSON.stringify คุณสามารถใช้:

code:
var myE = eval('["e",{"pluribus///unum"}]');
เพื่อรับวัตถุ myE

ทำให้เป็นอนุกรมเป็น JSON ใน JavaScript—ใช้ Prototype.js

หากคุณเป็นเหมือนฉันและต้องการใช้เฟรมเวิร์ก JavaScript แบบโอเพ่นซอร์สในโปรเจ็กต์ของคุณ คุณอาจข้ามการใช้ไฟล์ json2.js ได้ ในตัวอย่างนี้ สามารถดาวน์โหลดไฟล์ได้ที่ http://www.prototypejs.org เนื่องจากบทความนี้ไม่เกี่ยวกับเฟรมเวิร์ก JavaScript ฉันจึงถือว่าคุณมีความเข้าใจเกี่ยวกับการใช้ Prototype.js บ้างแล้ว
Prototype.js จัดเตรียมเมธอด toJSON สำหรับอ็อบเจ็กต์ Object คุณสามารถใช้เมธอด Object.toJSON() เพื่อให้ได้ซีเรียลไลซ์ของอ็อบเจ็กต์ ตัวอย่างเช่น:

รหัส:
วาร์แมว=
-
ชื่อ:"เฮลโลคิตตี้",
ส่วนสูง:"แอปเปิ้ล 6 ผล"
-
การแจ้งเตือน (Object.toJSON (cat));
//กล่องโต้ตอบจะปรากฏขึ้นพร้อมกับเนื้อหา {"name": "hellokitty", "height": "6 apples"}
นอกจากนี้ ยังมีการรองรับ JSON เพิ่มเติมใน Prototype.js ซึ่งส่วนใหญ่เป็นการแยกวิเคราะห์เนื้อหา JSON ในคำขอส่งคืน Ajax ในออบเจ็กต์ Ajax สิ่งนี้ไม่เกี่ยวข้องกับเนื้อหาของเราในขณะนี้และจะไม่ถูกนำมาใช้อีก

PHP และ JSON

ข้างต้น เราได้เรียนรู้เกี่ยวกับวิธีการซีเรียลไลซ์อ็อบเจ็กต์ใน PHP และวิธีการซีเรียลไลซ์อ็อบเจ็กต์ลงใน JSON ใน JavaScript คุณอาจจะสงสัยว่าทำไมฉันจึงรวมทั้งสองเข้าด้วยกัน เพราะจริงๆ แล้วไวยากรณ์ของพวกมันไม่เหมือนกันทุกประการ ใน PHP เป็นไปได้ที่จะดีซีเรียลไลซ์ข้อความ JSON และยังเป็นไปได้ที่จะทำให้วัตถุ PHP เป็นอนุกรมเป็น JSON แทนข้อความสไตล์ PHP อีกด้วย ซึ่งส่วนใหญ่ทำได้โดยสองฟังก์ชัน json_decode และ json_encode โปรดทราบว่าทั้งสองฟังก์ชันนี้รองรับใน PHP 5 >= 5.2.0 เท่านั้น หากคุณต้องการเขียนโปรแกรมที่ทำงานในสภาพแวดล้อม PHP4 ดังนั้นทั้งสองฟังก์ชันนี้ ไม่สามารถใช้งานได้

ไวยากรณ์ของ

ฟังก์ชัน json_decode

ผสม json_decode ( string $json [, bool $assoc] )
รับข้อความที่เข้ารหัส JSON และแปลงเป็น

json

พารามิเตอร์

ข้อความที่เข้ารหัส JSON
รศ
เมื่อค่า TRUE คืนค่าเป็นอาร์เรย์ที่เชื่อมโยง

ค่าที่ส่งคืน

เป็นวัตถุ หรือหากพารามิเตอร์ assoc ที่ไม่บังคับเป็น TRUE

ไวยากรณ์

ของฟังก์ชัน json_encode

(ผสม $value)

ค่า

พารามิเตอร์

นิพจน์ JSON

ค่าที่จะเข้ารหัสอาจเป็นพารามิเตอร์ประเภทใดก็ได้ ยกเว้นทรัพยากร ฟังก์ชันนี้ใช้งานได้ในรูปแบบการเข้ารหัส UTF-8 เท่านั้น

ส่ง

คืน

ข้อความ JSON ที่เข้ารหัสเมื่อ

สำเร็จ สมมติว่าเรามีโมดูลการลงทะเบียนผู้ใช้ซึ่งทำงานในลักษณะ "เชิงวัตถุ" ในอินสแตนซ์ฟังก์ชัน json_decode เราเปลี่ยนข้อมูลการลงทะเบียนของผู้ใช้เป็นแอตทริบิวต์คลาสในเบื้องหน้าแล้วส่งต่อไปยังพื้นหลัง php (เพื่อความง่าย ที่นี่ไม่ได้ใช้ Ajax) ในตัวอย่าง json_encode เราอ้างอิงไฟล์ js ในไฟล์ html ที่อยู่ชี้ไปที่ไฟล์ php และส่งออกออบเจ็กต์ผู้ใช้ที่เข้ารหัส json ในไฟล์ php (เพื่อความเรียบง่าย เราจะสร้างออบเจ็กต์โดยตรงโดยไม่ได้รับข้อมูลจาก ฐานข้อมูล) และส่งออกในรูปแบบ html
เอาล่ะ มาดูที่ส่วนหน้า json_encode.htm กันก่อน หน้านี้เลียนแบบหน้าการลงทะเบียนปกติ มีแบบฟอร์มอยู่ด้วย เมื่อส่งแล้ว ฟังก์ชัน JavaScript จะถูกทริกเกอร์ ผู้ใช้อ็อบเจ็กต์ผู้ใช้จะถูกสร้างขึ้น และเนื้อหาในแบบฟอร์ม ถูกตั้งค่าเป็นวัตถุผู้ใช้ สร้างข้อความ JSON และส่งผ่านไปยังไฟล์ json_encode.php พื้นหลังในโหมด POST ในไฟล์ js_encode.php ให้ใช้ฟังก์ชัน json_decode เพื่อแยกวิเคราะห์ข้อความ JSON ลงในออบเจ็กต์ PHP แล้วส่งออกออกมา
เอาล่ะ มาดูไฟล์ json_encode.html กันก่อน โค้ดของไฟล์จะเป็นดังนี้

:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd ">
<html xmlns=" http://www.w3.org/1999/xhtml ">
<หัว>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>json_decode</title>
<script src="json2.js" type="text/javascript"></script>
<script type="text/javascript">
ฟังก์ชัน JSON_test(o){
ผู้ใช้ var = {
ชื่อ:document.getElementById('txt_name').value,
อีเมล:document.getElementById('txt_email').value,
รหัสผ่าน:document.getElementById('txt_name').value
-
var json_string = JSON.stringify(ผู้ใช้);

document.getElementById('txt_json').value=json_string;
alert("คลิกตกลงเพื่อส่งแบบฟอร์ม");
o.ส่ง();
-
</สคริปต์>
</หัว>
<ร่างกาย>
<form id="form1" name="form1" method="post" action="json_encode.php" onsubmit="JSON_test(this)">
<label for="txt_name">ชื่อ</label>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_name" id = "txt_name" />
</p>
<label for="txt_email">อีเมล</label>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_email" id = "txt_email" />
</p>
<p>
<label for="txt_password">รหัสผ่าน</label>
</p>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_password" id = "txt_password" />
</p>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_json" id = "txt_json" />
<label for="button"></label>
<input type="submit" name="button" id="button" value="JSON" />
</p>
</แบบฟอร์ม>
</ร่างกาย>
</html>
เมื่อส่งแบบฟอร์มแล้ว ฟังก์ชัน JavaScript JSON_text() จะถูกทริกเกอร์ ขั้นแรกฟังก์ชันนี้จะสร้างผู้ใช้ออบเจ็กต์ JavaScript ตั้งชื่อ อีเมล และรหัสผ่านเป็นค่าของแบบฟอร์มที่เกี่ยวข้อง จากนั้นใช้ JSON.stringify วิธีการของไฟล์ json2.js เป็น จะถูกแปลงเป็นข้อความ JSON json_string และในที่สุดก็ตั้งค่าฟิลด์ที่ซ่อนอยู่ (เพื่อให้ชัดเจนที่นี่ ฉันแสดงฟิลด์ที่ซ่อนอยู่นี้ในรูปแบบของกล่องข้อความ) ค่าของ txt_json คือ json_string และส่งแบบฟอร์มแล้ว
ถัดไปไปที่ไฟล์ json_encode.php ดังนี้:

รหัส:
<?php
$json_string = $_POST["txt_json"];
ถ้า(ini_get("magic_quotes_gpc")=="1")
-
$json_string=stripslashes($json_string);
-
$user = json_decode($json_string);
echo var_dump($ผู้ใช้);
-
ในไฟล์นี้ ขั้นแรกให้รับค่าของฟิลด์แบบฟอร์ม POST txt_json ในไฟล์ json_encode.html ใส่ลงในตัวแปร $json_string จากนั้นตัดสินว่าหากการตั้งค่า PHP ปัจจุบันเป็น magic_quotes_gpc=On นั่นคือเครื่องหมายคำพูดคู่ที่เข้ามา จะถูกแปลงความหมาย ดังนั้นฟังก์ชัน json_decode จึงไม่สามารถแยกวิเคราะห์ได้ ดังนั้นเราจึงจำเป็นต้องหลีกเลี่ยงมัน

นั้น

ใช้ฟังก์ชัน json_decode เพื่อแปลงข้อความ JSON ให้เป็นอ็อบเจ็กต์ บันทึกลงในตัวแปร $user และสุดท้ายใช้ echo var_dump($user); เพื่อดัมพ์อ็อบเจ็กต์

วัตถุ (stdClass) # 1 (3) {
["ชื่อ"]=>
สตริง (10) "hanguofeng"
["อีเมล"]=>
string(18) " [email protected] "
["รหัสผ่าน"]=>
สตริง (10) "hanguofeng"
-

อินสแตนซ์ฟังก์ชัน json_encode

ยังคงประกอบด้วยสองส่วน คือ json_enode.html และ json_encode.php ในไฟล์ json_decode.html โดยทั่วไปแบบฟอร์มจะคล้ายกับไฟล์ json_decode.html แต่ข้อแตกต่างคือคราวนี้เราต้องการรับข้อความ JSON ของผู้ใช้ที่เกี่ยวข้องจากไฟล์ json_encode.php มาดูไฟล์ PHP นี้กัน อันดับแรก:

รหัส:
<?php
ผู้ใช้คลาส{
สาธารณะ $name="";
สาธารณะ $email="";
สาธารณะ $password="";
-
$myUser = ผู้ใช้ใหม่;
$myUser->name="hanguofeng";
$myUser->email=" [email protected] ";
$myUser->รหัสผ่าน = "hanguofeng";
$json_string = json_encode($myUser);
-
ผู้ใช้ var = <?php echo($json_string)?>;
ไฟล์นี้จะสร้างผู้ใช้คลาสก่อน จากนั้นรับอินสแตนซ์ของคลาสผู้ใช้ myUser และตั้งชื่อผู้ใช้ อีเมล และรหัสผ่าน จากนั้นจะใช้ฟังก์ชัน json_encode เพื่อแปลงเป็นข้อความ JSON บันทึกลงในตัวแปร $json_string และสุดท้าย ส่งออกโค้ด JavaScript เพื่อสร้างผู้ใช้ตัวแปรโกลบอลใน JavaScript
ต่อไป เราต้องแนะนำไฟล์ json_encode.php ลงในไฟล์ json_encode.html และรับคุณสมบัติต่างๆ ของอ็อบเจ็กต์ผู้ใช้ ดังนี้:

รหัส:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd ">
<html xmlns=" http://www.w3.org/1999/xhtml ">
<หัว>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>json_encode</title>
<script src="json_encode.php" type="text/javascript"></script>
</หัว>
<ร่างกาย>
<form id="form1" name="form1" method="post">
<label for="txt_name">ชื่อ</label>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_name" id = "txt_name" />
</p>
<label for="txt_email">อีเมล</label>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_email" id = "txt_email" />
</p>
<p>
<label for="txt_password">รหัสผ่าน</label>
</p>
<p>
<ประเภทอินพุต = "ข้อความ" ชื่อ = "txt_password" id = "txt_password" />
</p>
</แบบฟอร์ม>
<ประเภทสคริปต์ = "ข้อความ/จาวาสคริปต์" >
document.getElementById('txt_name').value=user.name;
document.getElementById('txt_email').value=user.email;
document.getElementById('txt_password').value=user.password;
</สคริปต์>
</ร่างกาย>
</html>
ในไฟล์นี้ คุณต้องใส่ใจกับสองประเด็น อย่างแรกคือเราแนะนำไฟล์ json_encode.php เป็นไฟล์ JavaScript ด้วยโค้ดนี้:

รหัส:
<script src="json_encode.php" type="text/javascript"></script>
ประเด็นที่สองคือ:
เราเพิ่มโค้ด JavaScript หลังโค้ดกล่องข้อความ ดำเนินการแอตทริบิวต์ value ของกล่องข้อความ และตั้งค่าเป็นค่าที่สอดคล้องกันของอ็อบเจ็กต์ผู้ใช้