วิธีเขียน JSON array และ object: โครงสร้างและการซ้อนกันสำหรับผู้เริ่มต้น
สรุปสำคัญ: JSON มีภาชนะแค่สองชนิด: object สำหรับฟิลด์ที่มีชื่อ, array สำหรับรายการที่เรียงลำดับ เรียนรู้การผสมทั้งสอง การเลือกให้ถูกชนิด และการแก้สามข้อผิดพลาดที่พบบ่อยที่สุด — array ปลอมที่ใช้ key เป็นตัวเลข, คอมม้าท้าย และ single quote

JSON ให้ภาชนะกับคุณแค่สองชนิด: object บรรทุกฟิลด์ที่มีชื่อ, array บรรทุกรายการที่เรียงลำดับ — และ payload ที่พังเกือบทุกกรณีอธิบายได้ด้วยเครื่องหมายคำพูด คอมม้า หรือรายการที่เขียนเป็น object ปลอม
หนึ่ง: JSON มีภาชนะแค่สองชนิด
ไม่ว่า response ของ API จะซับซ้อนแค่ไหน ทุกอย่างย่อลงเหลือภาชนะสองชนิดและค่าหกชนิด คือ object ที่เป็นคอลเลกชันของคู่ key/value ห่อด้วยวงเล็บปีกกา {} และ array ที่เป็นรายการเรียงลำดับของค่าห่อด้วยวงเล็บเหลี่ยม [] ค่าหนึ่งอาจเป็น string, number, true, false, null — หรือเป็น object หรือ array อีกที object อยู่ใน array, array อยู่ใน object: recursion นี่เองคือพลังการแสดงออกทั้งหมดของ JSON
{
"user": { "name": "Ada", "active": true },
"roles": ["admin", "editor"],
"lastLogin": null,
"loginCount": 42
}
จากนี้ได้ข้อสรุปเชิงปฏิบัติ: เจอ payload ที่งง อย่าอ่านทีละตัวอักษร ให้ดูก่อนว่าอักษรนอกสุดเป็น { หรือ [ ถ้าเป็น object ให้อ่านเป็นฟิลด์ที่มีชื่อ ถ้าเป็น array ให้อ่านเป็นรายการแล้วไล่ลงไปทีละชั้น แผนภาพไวยากรณ์บน json.org พอดีหนึ่งหน้าพอดีก็เพราะโครงสร้างสองชนิดบวก recursion ครอบคลุมทุกอย่างแล้ว
สอง: การเขียน object, กติกาเข้มสี่ข้อ
object คือจุดที่มือใหม่พลาดมากที่สุด แต่กติกาย่อเหลือสี่ข้อ:
- key ต้องเป็น string ครอบด้วย double quote
{name: "Ada"}และ{'name': 'Ada'}ไม่ถูกต้องทั้งคู่ ต้องเขียน{"name": "Ada"}object literal ของ JavaScript ยอมรับ key เปล่าและ single quote แต่ JSON ไม่ยอม — นี่คือจุดสับสนที่พบบ่อยที่สุดระหว่างสองตัวนี้ - คั่นคู่ด้วยคอมม้า และห้ามทิ้งคอมม้าหลังคู่สุดท้าย
{"a": 1, "b": 2,}จะพังด้วยUnexpected token }ที่วงเล็บปีกกาปิด - key ควรไม่ซ้ำกัน RFC 8259 พูดว่า SHOULD ไม่ใช่ MUST: key ซ้ำไม่ทำให้เกิดข้อผิดพลาด แต่จะเก็บค่าตัวแรกหรือตัวสุดท้ายขึ้นกับการ implement ซึ่งแต่ละภาษาไม่เหมือนกัน อย่าพึ่งพามันเด็ดขาด
- ลำดับของ key ไม่มีความหมาย
{"a":1,"b":2}กับ{"b":2,"a":1}เป็น object เดียวกัน เครื่องมือ diff และฟังก์ชันเปรียบเทียบไม่สนใจลำดับ key ถ้าลำดับสำคัญ ข้อมูลนั้นควรอยู่ใน array
สาม: การเขียน array, ลำดับคือข้อมูลเอง
array เก็บค่าตามตำแหน่งและเลข index เริ่มที่ 0: ใน ["admin", "editor"] สตริง "editor" คือ [1] ลำดับนี้มีความหมาย — นี่คือความต่างสำคัญระหว่าง array กับ object ผลการค้นหาที่จัดอันดับตามความเกี่ยวข้อง บันทึก log ที่เรียงตามวันที่: ข้อมูลแบบนี้มีชีวิตอยู่ในลำดับเท่านั้น และการเปลี่ยนเป็น object คือการทำลายมัน
คำแนะนำเชิงปฏิบัติสองข้อ หนึ่ง คงความเป็นเนื้อเดียวของสมาชิกไว้: [{"id":1},{"id":2}] กินง่ายกว่า [1, "text", true] อย่างมาก — อันหลังถูกกฎหมาย แต่บังคับผู้ใช้ทุกฝ่ายต้องเช็ก type ทุกขั้น สอง array เปล่า [] เป็นค่าที่ถูกต้องสมบูรณ์ — เมื่อฟิลด์รายการยังไม่มีเนื้อหา ส่ง [] แทน null เพื่อให้ผู้ใช้ไม่ต้องเช็กว่ามีอยู่แล้วเช็กอีกทีว่าว่าง
[
{ "city": "Tokyo", "population": 13960000 },
{ "city": "Delhi", "population": 16780000 }
]
สี่: การซ้อนกัน, สี่รูปทรงของ payload จริง
ข้อมูลจริงก็มีแค่ภาชนะสองชนิดนี้ซ้อนกันอยู่ในตัว และ pattern ย่อเหลือสี่รูปทรง:
| รูปทรง | หน้าตา | การใช้งานทั่วไป |
|---|---|---|
| object บรรจุ array | {"tags": ["a","b"]} |
ฟิลด์รายการของเอนทิตี |
| array ของ object | [{"id":1},{"id":2}] |
รายการเรคคอร์ด, ผลลัพธ์แบบแบ่งหน้า |
| object บรรจุ object | {"db": {"host": "..."}} |
config แบบจัดกลุ่ม, บล็อกที่อยู่ |
| array ของ array | [[1,2],[3,4]] |
เมทริกซ์, แถวของตาราง |
response ของ API ทั่วไปใช้ object เป็นเปลือกและ array เป็นเนื้อหา:
{
"code": 0,
"data": {
"items": [
{ "id": 1, "title": "first" },
{ "id": 2, "title": "second" }
],
"page": 1,
"total": 2
}
}
อย่าซ้อนเพราะอยากซ้อน เกินสามหรือสี่ชั้น เส้นทางเข้าถึงจะอ่านไม่ออก และโค้ดฝั่งผู้ใช้ก็บวมไปตาม ฟิลด์ที่เดินทางมาด้วยกันเสมอควรอยู่ใน sub-object: เปลี่ยน addrCity กับ addrZip เป็น address: {city, zip}
ห้า: object หรือ array, ตารางตัดสินใจ
| คำถาม | คำตอบ | เพราะอะไร |
|---|---|---|
| ทุกค่ามีชื่อของตัวเอง? | object | เข้าถึงผ่าน key; เพิ่มหรือลบฟิลด์ไม่ทำอะไรพัง |
| เป็นรายการเรคคอร์ดที่คล้ายกัน? | array | ลำดับสำคัญ; map และ filter ได้ |
| ต้องค้นหาเร็วผ่าน key? | object ที่ index ด้วยตัวระบุ | เข้าถึง O(1) แทนการวนไล่ |
| หลาย attribute ของเอนทิตีเดียว? | object | attribute ไม่มีลำดับของตัวเอง |
| คอลเลกชันที่โตขึ้นของสิ่งคล้ายกัน? | array | ความยาวยืดได้อิสระ |
anti-pattern หนึ่งสมควรได้รับการกล่าวถึงเป็นพิเศษ: เลียนแบบ array ด้วย object ที่ key เป็น "0", "1", "2" มัน parse ผ่านโดยไม่ error แต่คุณเสียความหมายของความยาวและเครื่องมือวนซ้ำของ array จริง และฝั่งผู้ใช้ต้องเรียง Object.keys ก่อนอ่านอะไรได้ ถ้า key เป็นเลขลำดับ ให้เขียน array จริง ด้านตรงข้ามก็จริงเช่นกัน: รายการคู่ key/value แบบ [{"key":"theme","value":"dark"}] เลวกว่า object {"theme": "dark"} — เว้นแต่ key นั้นเป็น dynamic จริง ๆ และประกาศล่วงหน้าไม่ได้
หก: สามข้อผิดพลาดที่พบบ่อยและข้อความของมัน
| รูปที่ผิด | error ทั่วไป | วิธีแก้ |
|---|---|---|
คอมม้าท้าย {"a":1,} |
Unexpected token } |
เอาคอมม้าตัวสุดท้ายออก |
single quote / key เปล่า {name:'Ada'} |
Unexpected token ' / Expected property name |
double quote สำหรับ key และ string เสมอ |
literal ของ Python True / None |
Unexpected token T |
เปลี่ยนเป็น true / null |
| array ปลอมใช้ key เป็นตัวเลข | ไม่ error, ความหมายผิด | เขียนใหม่เป็น array จริง |
นิสัยดีบักสองอย่าง: parser มักรายงานตำแหน่ง หลัง ตัวอักษรตัวร้าย เมื่อเห็น position 42 ให้มองถอยหลังหนึ่งถึงสองตัว และ JSON ยักษ์บรรทัดเดียวควร format ก่อน — เลขบรรทัดและคอลัมน์ชนะ offset ตัวอักษรทุกครั้ง แคตตาล็อก error ฉบับเต็มอยู่ที่ ตารางค้นหา error ของ JSON และขั้นตอนคัดแยกทีละขั้นอยู่ที่ วิธีแก้ parse error ของ JSON
เจ็ด: เขียนเสร็จแล้ว ตรวจโครงสร้าง
JSON เขียนมือควรผ่าน parser ก่อนส่งมอบเสมอ การตรวจที่เบาที่สุดอยู่ในหนึ่งบรรทัดคำสั่ง:
python3 -m json.tool config.json > /dev/null && echo OK
jq empty config.json && echo OK
ออนไลน์ วางเนื้อหาลงหน้า ตัวจัดรูปและตัวตรวจ JSON — error ไวยากรณ์จะกลับมาพร้อมเลขบรรทัดและคอลัมน์ สลับไปมุมมองแบบต้นไม้เพื่อดู type ของแต่ละชั้นในหนึ่งวินาที: มีตัวเลขถูกตีความเป็น string หรือไม่ ความยาว array ตรงกันหรือไม่ และเมื่อผู้อ่านไม่ใช่สายเทคนิค payload แบบ array-of-objects ทำเป็นแถวและคอลัมน์ได้ที่หน้า JSON เป็นตาราง ซึ่งไป ๆ มา ๆ ก็ตรวจให้ด้วยว่าข้อมูลของคุณเป็นรายการเรคคอร์ดที่คล้องจองกันจริงหรือไม่
คำถามเรื่องฟิลด์ที่ควรเป็น array หรือการจัดโครงสร้างซ้อนลึกเกินใหม่ เป็นเรื่องการออกแบบ type — อ่านต่อได้ที่ หกชนิด type, ความแม่นของตัวเลข และกับดัก encoding
JSON array กับ object เปลี่ยนข้ามกันได้ไหม?
ได้ แต่ไม่ได้ไม่เสียอะไรเลย แปลง object เป็น array มักหมายถึงเปลี่ยน key เป็นค่าและเสียการเข้าถึงผ่าน key แปลง array เป็น object ต้องสร้าง key ให้ทุกสมาชิก และที่มาของ key เหล่านั้นกลายเป็นโจทย์ออกแบบใหม่ทันที ตัดสินใจจากวิธีที่ฝั่งผู้ใช้อ่านข้อมูล ไม่ใช่จากความสะดวกทางไวยากรณ์
key ของ object ซ้ำกันได้ไหม?
ตามไวยากรณ์ได้ — RFC 8259 บอกแค่ว่า key SHOULD ไม่ซ้ำ แต่ JavaScript เก็บค่าตัวสุดท้าย ขณะที่บางไลบรารีตระกูล C เก็บตัวแรก: พฤติกรรมต่างกันตาม parser ในลายเซ็น diff หรือ hash ของ key ที่ซ้ำจะก่อความไม่ตรงกันโดยตรง เลี่ยงไว้ในฝั่งผู้ผลิต และถือว่า key ซ้ำจากแหล่งไม่รู้จักเป็นความเสี่ยงฝั่งผู้ใช้
array เก็บค่าต่างชนิดได้ไหม?
ตามไวยากรณ์ได้: [1, "a", true] เป็น JSON ที่ถูกต้อง แต่ array ที่ไม่เนื้อเดียวบังคับฝั่งผู้ใช้ให้เช็ก type ทุกตำแหน่ง และเขียนอธิบายใน schema ได้ยาก นอกจากเมทริกซ์กับ tuple — ที่ตำแหน่งคือความหมายเอง — คงความเป็นเนื้อเดียวของ array ไว้
ทำไม {name:'json'} ตรวจไม่ผ่าน?
เพราะ JSON เรียกร้อง double quote ล้อมทุก key และทุกค่าชนิด string {name:'json'} เป็น object literal ของ JavaScript ไม่ใช่ JSON เปลี่ยนเป็น {"name": "json"} แล้วการตรวจจะผ่าน single quote, key เปล่า และคอมเมนต์เป็นของภาษาถิ่นอย่าง JSON5/JSONC ซึ่งต้องใช้ parser ของตัวเองแทน JSON.parse มาตรฐาน