วิธีการ JSON ถึง JSON

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

โดยปกติแล้ว สตริงดังกล่าวควรมีคุณสมบัติที่สำคัญทั้งหมด

เราสามารถใช้การแปลงเช่นนี้:

 ให้ผู้ใช้ = {
  ชื่อ: "จอห์น"
  อายุ: 30,

  toString() {
    ส่งคืน `{ชื่อ: "${this.name}", อายุ: ${this.age}}`;
  -
-

การแจ้งเตือน (ผู้ใช้); // {ชื่อ: "จอห์น" อายุ: 30}

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

โชคดีที่ไม่จำเป็นต้องเขียนโค้ดเพื่อจัดการทั้งหมดนี้ งานได้รับการแก้ไขแล้ว

JSON.stringify

JSON (สัญลักษณ์วัตถุ JavaScript) เป็นรูปแบบทั่วไปเพื่อแสดงค่าและวัตถุ มีการอธิบายไว้ในมาตรฐาน RFC 4627 ในตอนแรกมันถูกสร้างมาเพื่อ JavaScript แต่ภาษาอื่น ๆ มากมายก็มีไลบรารี่ที่จะจัดการเช่นกัน ดังนั้นจึงเป็นเรื่องง่ายที่จะใช้ JSON สำหรับการแลกเปลี่ยนข้อมูลเมื่อไคลเอนต์ใช้ JavaScript และเซิร์ฟเวอร์เขียนบน Ruby/PHP/Java/อะไรก็ตาม

JavaScript มีวิธีการ:

• JSON.stringify เพื่อแปลงวัตถุเป็น JSON

• JSON.parse เพื่อแปลง JSON กลับเป็นวัตถุ

ตัวอย่างเช่น ที่นี่เรา JSON.stringify นักเรียน:

 ให้นักเรียน = {
  ชื่อ: 'จอห์น'
  อายุ: 30,
  isAdmin: เท็จ
  หลักสูตร: ['html', 'css', 'js'],
  คู่สมรส: null
-

ให้ json = JSON.stringify(student);

การแจ้งเตือน (ประเภทของ json); // เรามีเชือกแล้ว!

การแจ้งเตือน (json);
/* วัตถุที่เข้ารหัส JSON:
-
  "ชื่อ": "จอห์น",
  "อายุ": 30,
  "isAdmin": เท็จ
  "หลักสูตร": ["html", "css", "js"],
  "คู่สมรส": null
-
-

วิธีการ JSON.stringify(student) ใช้วัตถุและแปลงเป็นสตริง

สตริง json ที่เป็นผลลัพธ์เรียกว่าอ็อบเจ็กต์ ที่เข้ารหัส JSON หรือ ซีเรียลไลซ์ หรือ สตริง หรือ จัดเรียง เราพร้อมส่งผ่านสายหรือใส่ลงในที่เก็บข้อมูลธรรมดา

โปรดทราบว่าออบเจ็กต์ที่เข้ารหัส JSON มีความแตกต่างที่สำคัญหลายประการจากออบเจ็กต์ตามตัวอักษร:

• สตริงใช้เครื่องหมายคำพูดคู่ ไม่มีเครื่องหมายคำพูดเดี่ยวหรือเครื่องหมายย้อนกลับใน JSON 'John' จึงกลายเป็น "John"

• ชื่อคุณสมบัติของอ็อบเจ็กต์ก็มีเครื่องหมายคำพูดคู่เช่นกัน นั่นเป็นข้อบังคับ ดังนั้น age:30 จะกลายเป็น "age":30

JSON.stringify สามารถนำไปใช้กับพื้นฐานได้เช่นกัน

JSON รองรับประเภทข้อมูลต่อไปนี้:

• วัตถุ { ... }

• อาร์เรย์ [ ... ]

• ดั้งเดิม:

• สตริง,

• ตัวเลข,

• ค่าบูลีน true/false ,

• null .

ตัวอย่างเช่น:

 // ตัวเลขใน JSON เป็นเพียงตัวเลข
การแจ้งเตือน ( JSON.stringify (1) ) // 1

// สตริงใน JSON ยังคงเป็นสตริง แต่มีเครื่องหมายคำพูดคู่
การแจ้งเตือน ( JSON.stringify ('ทดสอบ') ) // "ทดสอบ"

การแจ้งเตือน ( JSON.stringify(true) ); // จริง

การแจ้งเตือน( JSON.stringify([1, 2, 3]) ); // [1,2,3]

JSON เป็นข้อกำหนดเฉพาะที่ไม่ขึ้นอยู่กับภาษาของข้อมูลเท่านั้น ดังนั้นคุณสมบัติของออบเจ็กต์เฉพาะ JavaScript บางอย่างจึงถูกข้ามโดย JSON.stringify

กล่าวคือ:

• คุณสมบัติฟังก์ชัน (วิธีการ)

• คีย์สัญลักษณ์และค่า

• คุณสมบัติที่เก็บ undefined

 ให้ผู้ใช้ = {
  sayHi() { // ละเลย
    alert("สวัสดี");
  -
  [สัญลักษณ์("id")]: 123, // ละเว้น
  บางสิ่งบางอย่าง: ไม่ได้กำหนด // ละเว้น
-

การแจ้งเตือน ( JSON.stringify (ผู้ใช้) ); // {} (วัตถุว่าง)

ปกติก็ดีแล้ว หากนั่นไม่ใช่สิ่งที่เราต้องการ เร็วๆ นี้เราจะมาดูวิธีปรับแต่งกระบวนการกัน

สิ่งที่ยอดเยี่ยมก็คือวัตถุที่ซ้อนกันได้รับการสนับสนุนและแปลงโดยอัตโนมัติ

ตัวอย่างเช่น:

 มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ห้อง: {
    หมายเลข: 23,
    ผู้เข้าร่วม: ["john", "ann"]
  -
-

การแจ้งเตือน ( JSON.stringify (พบปะ) );
/* โครงสร้างทั้งหมดมีความเข้มงวด:
-
  "หัวข้อ":การประชุม",
  "room":{"number":23,"ผู้เข้าร่วม":["john","ann"]},
-
-

ข้อจำกัดที่สำคัญ: ต้องไม่มีการอ้างอิงแบบวงกลม

ตัวอย่างเช่น:

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ผู้เข้าร่วม: ["john", "ann"]
-

meetup.place = ห้อง;       // ห้องอ้างอิงการพบปะ
room.occupiedBy = พบปะ; // การประชุมอ้างอิงห้อง

JSON.stringify(พบปะ); // ข้อผิดพลาด: การแปลงโครงสร้างแบบวงกลมเป็น JSON

ที่นี่ การแปลงล้มเหลว เนื่องจากมีการอ้างอิงแบบวงกลม: room.occupiedBy References meetup และ meetup.place References room :

การยกเว้นและการเปลี่ยนแปลง: การแทนที่

ไวยากรณ์แบบเต็มของ JSON.stringify คือ:

 ให้ json = JSON.stringify (ค่า [, ตัวแทนที่, ช่องว่าง])

• ค่า

• ค่าที่จะเข้ารหัส

• ทดแทน

• อาร์เรย์ของคุณสมบัติที่จะเข้ารหัสหรือฟังก์ชันการทำแผนที่ function(key, value)

• ช่องว่าง

• จำนวนพื้นที่ที่จะใช้สำหรับการจัดรูปแบบ

โดยส่วนใหญ่ JSON.stringify จะใช้กับอาร์กิวเมนต์แรกเท่านั้น แต่ถ้าเราจำเป็นต้องปรับแต่งกระบวนการแทนที่อย่างละเอียด เช่น เพื่อกรองการอ้างอิงแบบวงกลมออกไป เราสามารถใช้อาร์กิวเมนต์ที่สองของ JSON.stringify ได้

หากเราส่งผ่านอาร์เรย์ของคุณสมบัติไป เฉพาะคุณสมบัติเหล่านี้เท่านั้นที่จะถูกเข้ารหัส

ตัวอย่างเช่น:

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ผู้เข้าร่วม: [{ชื่อ: "จอห์น"}, {ชื่อ: "อลิซ"}],
  สถานที่: ห้อง // ห้องอ้างอิงการพบปะ
-

room.occupiedBy = พบปะ; // การประชุมอ้างอิงห้อง

alert( JSON.stringify(พบปะ, ['ชื่อ', 'ผู้เข้าร่วม']) );
// {"title":"การประชุม", "ผู้เข้าร่วม":[{},{}]}

ที่นี่เราอาจจะเข้มงวดเกินไป รายการคุณสมบัติถูกนำไปใช้กับโครงสร้างวัตถุทั้งหมด ดังนั้นออบเจ็กต์ใน participants จึงว่างเปล่า เนื่องจาก name ไม่อยู่ในรายการ

มารวมทุกคุณสมบัติในรายการยกเว้น room.occupiedBy ที่จะทำให้เกิดการอ้างอิงแบบวงกลม:

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ผู้เข้าร่วม: [{ชื่อ: "จอห์น"}, {ชื่อ: "อลิซ"}],
  สถานที่: ห้อง // ห้องอ้างอิงการพบปะ
-

room.occupiedBy = พบปะ; // การประชุมอ้างอิงห้อง

alert( JSON.stringify(พบปะ, ['ชื่อ', 'ผู้เข้าร่วม', 'สถานที่', 'ชื่อ', 'หมายเลข']) );
-
-
  "หัวข้อ":การประชุม",
  "participants":[{"name":John" บัลชื่อ":Alice"}],
  "สถานที่":{"หมายเลข":23}
-
-

ตอนนี้ทุกอย่างยกเว้น occupiedBy จะถูกทำให้เป็นอนุกรม แต่รายการคุณสมบัติค่อนข้างยาว

โชคดีที่เราสามารถใช้ฟังก์ชันแทน replacer แทนได้

ฟังก์ชันนี้จะถูกเรียกใช้สำหรับทุกคู่ (key, value) และควรส่งคืนค่า "แทนที่" ซึ่งจะถูกใช้แทนค่าเดิม หรือ undefined หากจะข้ามค่า

ในกรณีของเรา เราสามารถคืน value "ตามที่เป็น" สำหรับทุกสิ่งยกเว้น occupiedBy หากต้องการละเว้น occupiedBy โค้ดด้านล่างจะส่งคืน undefined :

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ผู้เข้าร่วม: [{ชื่อ: "จอห์น"}, {ชื่อ: "อลิซ"}],
  สถานที่: ห้อง // ห้องอ้างอิงการพบปะ
-

room.occupiedBy = พบปะ; // การประชุมอ้างอิงห้อง

การแจ้งเตือน ( JSON.stringify (พบปะ, ตัวแทนที่ฟังก์ชัน (คีย์, ค่า) {
  alert(`${key}: ${value}`);
  return (คีย์ == 'ครอบครองโดย') ? ไม่ได้กำหนด : ค่า;
-

/* key:value คู่ที่มาแทนที่:
: [วัตถุวัตถุ]
หัวเรื่อง: การประชุม
ผู้เข้าร่วม: [วัตถุวัตถุ], [วัตถุวัตถุ]
0: [วัตถุวัตถุ]
ชื่อ: จอห์น
1: [วัตถุวัตถุ]
ชื่อ: อลิซ
สถานที่: [วัตถุวัตถุ]
หมายเลข: 23
ครอบครองโดย: [วัตถุวัตถุ]
-

โปรดทราบว่าฟังก์ชัน replacer ได้รับคู่คีย์/ค่าทุกคู่ รวมถึงอ็อบเจ็กต์ที่ซ้อนกันและรายการอาร์เรย์ มันถูกนำไปใช้แบบวนซ้ำ ค่าของ replacer ที่ภายใน this คือวัตถุที่มีคุณสมบัติปัจจุบัน

การโทรครั้งแรกเป็นพิเศษ มันถูกสร้างขึ้นโดยใช้ “วัตถุ wrapper” พิเศษ: {"": meetup} กล่าวอีกนัยหนึ่ง คู่แรก (key, value) มีคีย์ว่าง และค่าคือออบเจ็กต์เป้าหมายโดยรวม นั่นเป็นเหตุผลว่าทำไมบรรทัดแรกจึงเป็น ":[object Object]" ในตัวอย่างด้านบน

แนวคิดคือการจัดเตรียมกำลังให้กับ replacer ให้ได้มากที่สุด โดยมีโอกาสที่จะวิเคราะห์และแทนที่/ข้ามแม้แต่วัตถุทั้งหมดหากจำเป็น

การจัดรูปแบบ: ช่องว่าง

อาร์กิวเมนต์ที่สามของ JSON.stringify(value, replacer, space) คือจำนวนช่องว่างที่จะใช้สำหรับการจัดรูปแบบที่สวยงาม

ก่อนหน้านี้ วัตถุ stringified ทั้งหมดไม่มีการเยื้องและช่องว่างเพิ่มเติม ไม่เป็นไรถ้าเราต้องการส่งวัตถุผ่านเครือข่าย อาร์กิวเมนต์ space ใช้สำหรับเอาต์พุตที่ดีโดยเฉพาะ

ที่นี่ space = 2 บอกให้ JavaScript แสดงวัตถุที่ซ้อนกันบนหลายบรรทัด โดยมีช่องว่าง 2 ช่องภายในวัตถุ:

 ให้ผู้ใช้ = {
  ชื่อ: "จอห์น"
  อายุ: 25,
  บทบาท: {
    isAdmin: เท็จ
    isEditor: จริง
  -
-

การแจ้งเตือน (JSON.stringify (ผู้ใช้, null, 2));
/* เยื้องสองช่องว่าง:
-
  "ชื่อ": "จอห์น",
  "อายุ": 25,
  "บทบาท": {
    "isAdmin": เท็จ
    "isEditor": จริง
  -
-
-

/* สำหรับ JSON.stringify(user, null, 4) ผลลัพธ์จะเยื้องมากขึ้น:
-
    "ชื่อ": "จอห์น",
    "อายุ": 25,
    "บทบาท": {
        "isAdmin": เท็จ
        "isEditor": จริง
    -
-
-

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

พารามิเตอร์ space ใช้เพื่อวัตถุประสงค์ในการบันทึกและเอาต์พุตที่ดีเท่านั้น

กำหนดเอง “toJSON”

เช่นเดียวกับ toString สำหรับการแปลงสตริง วัตถุอาจจัดให้มีวิธีการ toJSON สำหรับการแปลงเป็น JSON JSON.stringify จะเรียกมันโดยอัตโนมัติหากมี

ตัวอย่างเช่น:

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  วันที่: วันที่ใหม่ (Date.UTC (2017, 0, 1)),
  ห้อง
-

การแจ้งเตือน ( JSON.stringify (พบปะ) );
-
  -
    "หัวข้อ":การประชุม",
    "date": "2017-01-01T00:00:00.000Z", // (1)
    "ห้อง": {"หมายเลข":23} // (2)
  -
-

ที่นี่เราจะเห็นว่า date (1) กลายเป็นสตริง นั่นเป็นเพราะว่าวันที่ทั้งหมดมีเมธอด toJSON ในตัวซึ่งส่งคืนสตริงประเภทนี้

ตอนนี้เรามาเพิ่มแบบกำหนดเองให้ toJSON สำหรับ object room ของเรา (2) :

 ให้ห้อง = {
  หมายเลข: 23,
  toJSON() {
    กลับ this.number;
  -
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ห้อง
-

การแจ้งเตือน ( JSON.stringify (ห้อง) ); // 23

การแจ้งเตือน ( JSON.stringify (พบปะ) );
-
  -
    "หัวข้อ":การประชุม",
    "ห้อง": 23
  -
-

ดังที่เราเห็น toJSON ใช้ทั้งสำหรับการเรียกโดยตรง JSON.stringify(room) และเมื่อ room ซ้อนอยู่ในวัตถุที่เข้ารหัสอื่น

JSON.แยกวิเคราะห์

ในการถอดรหัสสตริง JSON เราจำเป็นต้องมีวิธีอื่นชื่อ JSON.parse

ไวยากรณ์:

 ให้ค่า = JSON.parse (str [, ผู้ฟื้นคืนชีพ]);

• STR

• สตริง JSON ที่จะแยกวิเคราะห์

• ผู้ฟื้นคืนชีพ

• ฟังก์ชันเสริม (คีย์, ค่า) ที่จะถูกเรียกสำหรับแต่ละคู่ (key, value) และสามารถแปลงค่าได้

ตัวอย่างเช่น:

 // อาร์เรย์แบบ stringified
ให้ตัวเลข = "[0, 1, 2, 3]";

ตัวเลข = JSON.parse (ตัวเลข);

การแจ้งเตือน( ตัวเลข[1] ); // 1

หรือสำหรับวัตถุที่ซ้อนกัน:

 ให้ userData = '{ "name": "John", "age": 35, "isAdmin": false, "friends": [0,1,2,3] }';

ให้ผู้ใช้ = JSON.parse (userData);

การแจ้งเตือน ( user.friends[1] ); // 1

JSON อาจซับซ้อนเท่าที่จำเป็น อ็อบเจ็กต์และอาร์เรย์สามารถรวมอ็อบเจ็กต์และอาร์เรย์อื่นๆ ได้ แต่จะต้องเป็นไปตามรูปแบบ JSON เดียวกัน

นี่คือข้อผิดพลาดทั่วไปใน JSON ที่เขียนด้วยลายมือ (บางครั้งเราต้องเขียนเพื่อวัตถุประสงค์ในการแก้ไขจุดบกพร่อง):

 ให้ json = `{
  ชื่อ: "John", // ข้อผิดพลาด: ชื่อคุณสมบัติที่ไม่มีเครื่องหมายคำพูด
  "นามสกุล": 'Smith', // ข้อผิดพลาด: เครื่องหมายคำพูดเดี่ยวมีค่า (ต้องเป็นสองเท่า)
  'isAdmin': false // error: เครื่องหมายคำพูดเดี่ยวในคีย์ (ต้องเป็นสองเท่า)
  "วันเกิด": วันที่ใหม่ (2000, 2, 3), // ข้อผิดพลาด: ไม่อนุญาตให้ใช้ "ใหม่" เฉพาะค่าเปล่าเท่านั้น
  "เพื่อน": [0,1,2,3] // ไม่เป็นไร
-

นอกจากนี้ JSON ยังไม่รองรับความคิดเห็น การเพิ่มความคิดเห็นใน JSON ทำให้ไม่ถูกต้อง

มีอีกรูปแบบหนึ่งชื่อ JSON5 ซึ่งอนุญาตให้ใช้คีย์ที่ไม่มีเครื่องหมายคำพูด ความคิดเห็น ฯลฯ แต่นี่เป็นไลบรารีแบบสแตนด์อโลน ไม่ใช่ในข้อกำหนดของภาษา

JSON ปกตินั้นเข้มงวดมาก ไม่ใช่เพราะว่านักพัฒนาขี้เกียจ แต่เพื่อให้ใช้งานอัลกอริธึมการแยกวิเคราะห์ได้ง่าย เชื่อถือได้ และรวดเร็วมาก

การใช้รีไวเวอร์

ลองนึกภาพเราได้รับออบเจ็กต์ meetup ที่เข้มงวดจากเซิร์ฟเวอร์

ดูเหมือนว่านี้:

 // หัวข้อ: (ชื่อการพบปะ), วันที่: (วันที่การพบปะ)
ให้ str = '{"title:"Conference", "date": "2017-11-30T12:00:00.000Z"}';

…และตอนนี้เราจำเป็นต้อง ดีซีเรียลไลซ์ มัน เพื่อเปลี่ยนกลับเป็นอ็อบเจ็กต์ JavaScript

ทำได้โดยการเรียก JSON.parse :

 ให้ str = '{"title:"Conference", "date": "2017-11-30T12:00:00.000Z"}';

ให้ meetup = JSON.parse(str);

การแจ้งเตือน( meetup.date.getDate() ); // ข้อผิดพลาด!

อ๊ะ! เกิดข้อผิดพลาด!

ค่าของ meetup.date จะเป็นสตริง ไม่ใช่ออบเจ็กต์ Date JSON.parse จะรู้ได้อย่างไรว่าควรแปลงสตริงนั้นเป็น Date

ส่งต่อไปยัง JSON.parse ฟังก์ชันการฟื้นฟูเป็นอาร์กิวเมนต์ที่สอง ซึ่งจะส่งคืนค่าทั้งหมด “ตามสภาพ” แต่ date ที่จะกลายเป็น Date :

 ให้ str = '{"title:"Conference""date:"2017-11-30T12:00:00.000Z"}';

ให้ meetup = JSON.parse(str, function(key, value) {
  ถ้า (key == 'date') ส่งคืนวันที่ใหม่ (ค่า);
  ค่าส่งคืน;
-

การแจ้งเตือน( meetup.date.getDate() ); // ตอนนี้ใช้งานได้แล้ว!

อย่างไรก็ตาม มันใช้ได้กับวัตถุที่ซ้อนกันเช่นกัน:

 ให้กำหนดการ = `{
  "การพบปะ": [
    {"title": "การประชุม" "วันที่": 2017-11-30T12:00:00.000Z"},
    {"title": "วันเกิด" "" วันที่ "2017-04-18T12:00:00.000Z"}
  -
-

schedule = JSON.parse (กำหนดการ, ฟังก์ชั่น (คีย์, ค่า) {
  ถ้า (key == 'date') ส่งคืนวันที่ใหม่ (ค่า);
  ค่าส่งคืน;
-

การแจ้งเตือน ( schedule.meetups[1].date.getDate() ); // ได้ผล!

สรุป

• JSON คือรูปแบบข้อมูลที่มีมาตรฐานอิสระและมีไลบรารีสำหรับภาษาการเขียนโปรแกรมส่วนใหญ่

• JSON รองรับวัตถุธรรมดา อาร์เรย์ สตริง ตัวเลข บูลีน และ null

• JavaScript จัดให้มีวิธีการ JSON.stringify เพื่อทำให้อนุกรมเป็น JSON และ JSON.parse เพื่ออ่านจาก JSON

• ทั้งสองวิธีรองรับฟังก์ชันหม้อแปลงสำหรับการอ่าน/เขียนอัจฉริยะ

• หากวัตถุมี toJSON ก็จะถูกเรียกโดย JSON.stringify

งาน

เปลี่ยนวัตถุให้เป็น JSON และย้อนกลับ

ความสำคัญ: 5

เปลี่ยน user เป็น JSON แล้วอ่านกลับเป็นตัวแปรอื่น

 ให้ผู้ใช้ = {
  ชื่อ: "จอห์น สมิธ"
  อายุ: 35
-

สารละลาย

 ให้ผู้ใช้ = {
  ชื่อ: "จอห์น สมิธ"
  อายุ: 35
-

ให้ user2 = JSON.parse(JSON.stringify(user));

ยกเว้นการอ้างอิงกลับ

ความสำคัญ: 5

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

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

เขียนฟังก์ชัน replacer เพื่อทำให้ทุกอย่างเป็นสตริง แต่ลบคุณสมบัติที่อ้างอิงถึง meetup :

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ครอบครองโดย: [{ชื่อ: "จอห์น"}, {ชื่อ: "อลิซ"}],
  สถานที่: ห้อง
-

// การอ้างอิงแบบวงกลม
room.occupiedBy = พบปะ;
meetup.self = พบปะ;

การแจ้งเตือน ( JSON.stringify (พบปะ, ตัวแทนที่ฟังก์ชัน (คีย์, ค่า) {
  /* รหัสของคุณ */
-

/* ผลลัพธ์ควรเป็น:
-
  "หัวข้อ":การประชุม",
  "occupiedBy":[{"name"John" บัลชื่อ"Alice"}],
  "สถานที่":{"หมายเลข":23}
-
-

สารละลาย

 ให้ห้อง = {
  หมายเลข: 23
-

มาพบปะกัน = {
  หัวเรื่อง: "การประชุม",
  ครอบครองโดย: [{ชื่อ: "จอห์น"}, {ชื่อ: "อลิซ"}],
  สถานที่: ห้อง
-

room.occupiedBy = พบปะ;
meetup.self = พบปะ;

การแจ้งเตือน ( JSON.stringify (พบปะ, ตัวแทนที่ฟังก์ชัน (คีย์, ค่า) {
  return (คีย์ != "" && value == พบปะ) ? ไม่ได้กำหนด : ค่า;
-

-
-
  "หัวข้อ":การประชุม",
  "occupiedBy":[{"name"John" บัลชื่อ"Alice"}],
  "สถานที่":{"หมายเลข":23}
-
-

ที่นี่เรายังต้องทดสอบ key=="" เพื่อแยกการโทรครั้งแรกซึ่งเป็นเรื่องปกติที่ value นั้นคือ meetup