รวม JSON

#1ข้อมูลเข้า
#2ข้อมูลเข้า

เครื่องมือรวม JSON ออนไลน์ฟรี รวมออบเจกต์ JSON หลายรายการเป็นหนึ่งเดียวตามกลยุทธ์ที่กำหนด (Deep/Shallow/Array Concat/Array Replace) ในคลิกเดียว มีโหมดแก้ไขคอนฟลิกต์ 4 แบบ เหมาะสำหรับการรวมข้อมูลหลายแหล่ง การแบ่งชั้นคอนฟิก และการรวม i18n

คำแนะนำที่เกี่ยวข้อง

JSON Merge (การรวม JSON) คืออะไร?

JSON Merge คือการดำเนินการที่รวมออบเจกต์ JSON ตั้งแต่สองรายการขึ้นไปเป็นออบเจกต์ใหม่ตามกฎที่กำหนด เป็นการดำเนินการที่พบบ่อยมากในงานวิศวกรรม: ① รวม JSON ที่ส่งกลับจากหลาย microservice ให้เป็น response เดียว (การรวมที่ชั้น BFF); ② รวม base config, env config และ user config ตามหลักการ "ครอบคลุมตามสภาพแวดล้อม" ให้เป็นคอนฟิกสุดท้าย (Node.js config, Viper, Spring Cloud Config); ③ รวม ครอบคลุม และเติมเต็มไฟล์แปล i18n หลายไฟล์ให้เป็นพจนานุกรมที่สมบูรณ์; ④ รวมอาร์เรย์ mock data หลายชุดเป็นข้อมูลทดสอบที่สมบูรณ์; ⑤ รวม API response แบบแบ่งหน้าหลายรายการเป็นผลลัพธ์ทั้งหมด

จุดที่ยากของการรวมไม่ใช่การ "รวม" แต่คือ "จะจัดการคอนฟลิกต์อย่างไร" มีกลยุทธ์แก้ไขคอนฟลิกต์ที่พบบ่อย 4 แบบ: ① **Deep Merge (การรวมเชิงลึก)**: ลง recursive เข้าไปในออบเจกต์ที่ซ้อนกัน รวมแต่ละคีย์แยกกัน จะทับก็ต่อเมื่อมีคอนฟลิกต์ที่ leaf node เหมาะสำหรับการแบ่งชั้นคอนฟิก; ② **Shallow Merge (การรวมตื้น)**: รวมเฉพาะคีย์ระดับบนสุด คีย์ที่ชื่อซ้ำกันจะถูกทับทั้งบล็อก มีความหมายที่เรียบง่ายที่สุด คล้ายกับ `Object.assign`; ③ **Array Concat (การต่ออาร์เรย์)**: ค่าประเภทอาร์เรย์จะถูกต่อเป็นอาร์เรย์ยาวหนึ่งเดียวโดยคงลำดับองค์ประกอบทั้งหมด เหมาะสำหรับการรวม API; ④ **Array Replace (การแทนที่อาร์เรย์)**: ค่าประเภทอาร์เรย์จะใช้ค่าที่ป้อนทีหลังทับโดยตรง เหมาะสำหรับการครอบคลุมคอนฟิก

ในด้านการนำไปใช้ Deep Merge มักใช้การ recursive แบบ stack: ตรวจสอบก่อนว่าทั้งสองข้างเป็น plain object (ไม่ใช่อาร์เรย์ ไม่ใช่ null) จากนั้นประมวลผลแต่ละคีย์แบบ recursive; เมื่อพบชนิดข้อมูลไม่ตรงกัน (เช่น คีย์เดียวกันข้างหนึ่งเป็นออบเจกต์ อีกข้างหนึ่งเป็นอาร์เรย์) โดยทั่วไปจะใช้หลักการ "ค่าที่ป้อนทีหลังมีผล" และจะไม่ทำการแปลงชนิดข้อมูล เครื่องมือ JSON Merge ของ GeekFormat มีกลยุทธ์ 4 แบบดังกล่าวในตัว สามารถสลับได้โดยตรงบนหน้าเว็บ; สามารถวาง JSON 2 ถึง N ส่วน รวมตามลำดับอัตโนมัติ และแสดงผลลัพธ์ที่จัดรูปแบบเป็นหนึ่งเดียว กระบวนการรวมทั้งหมดเสร็จสิ้นในเบราว์เซอร์แบบโลคัล ข้อมูลดิบจะไม่ถูกอัปโหลด

กรณีการใช้งาน

  • รวม API response จากหลาย microservice เป็นโครงสร้าง JSON เดียวสำหรับใช้งานฟรอนต์เอนด์
  • รวมไฟล์คอนฟิกหลายชั้น base / dev / prod สร้างคอนฟิกสุดท้ายตามการครอบคลุมของสภาพแวดล้อม
  • รวมไฟล์แปล i18n หลายไฟล์ตามภาษา กำจัดรายการซ้ำ และเติมเต็มให้เป็นพจนานุกรมที่สมบูรณ์
  • รวมอาร์เรย์ mock data หลายชุดหรือ API response แบบแบ่งหน้าหลายรายการเป็นชุดข้อมูลที่สมบูรณ์
  • รวมคอนฟิกเริ่มต้นของคอมโพเนนต์ฟรอนต์เอนด์ + คอนฟิกที่ผู้ใช้กำหนดเอง + คอนฟิก A/B experiment จากระยะไกล
  • รวมไฟล์ส่งออก JSON จากระบบต้นทางหลายระบบในการย้ายข้อมูล ให้เป็นรูปแบบเดียวสำหรับระบบปลายทาง

วิธีการใช้งาน

  1. วาง JSON 2 ถึง N ส่วนที่ต้องการรวมตามลำดับลงในช่องป้อนค่าทางด้านซ้าย (ค่าเริ่มต้นมี 2 ช่อง) หรือคลิก「+」เพื่อเพิ่มช่องป้อนค่าเพิ่มเติม
  2. เลือกกลยุทธ์การรวมในดรอปดาวน์ของแถบเครื่องมือ: Deep Merge (เชิงลึก) / Shallow Merge (ตื้น) / Array Concat (ต่ออาร์เรย์) / Array Replace (แทนที่อาร์เรย์)
  3. คลิกปุ่ม「รวม」 ช่องผลลัพธ์ทางด้านขวาจะแสดงผลลัพธ์ที่จัดรูปแบบหลังจากรวม; หากข้อมูลที่ป้อนมีข้อผิดพลาดทางไวยากรณ์จะแสดงหมายเลขบรรทัดและข้อความแสดงข้อผิดพลาดโดยละเอียด
  4. หลังจากยืนยันว่าผลลัพธ์ถูกต้องแล้ว คลิก「คัดลอก」เพื่อวางผลลัพธ์การรวมลงในคลิปบอร์ด หรือคลิก「ดาวน์โหลด」เพื่อบันทึกเป็นไฟล์ merged.json เพื่อดำเนินการต่อ เช่น จัดรูปแบบ ตรวจสอบ Schema ฯลฯ

คุณสมบัติ

  • กลยุทธ์การรวม 4 แบบ: Deep Merge / Shallow Merge / Array Concat / Array Replace สลับได้ในคลิกเดียวเพื่อตอบสนองสถานการณ์ธุรกิจที่แตกต่างกัน
  • รองรับ JSON 2 ถึง N ส่วน: มีช่องป้อนค่า 2 ช่องโดยค่าเริ่มต้น สามารถกด「+」เพื่อเพิ่ม JSON ต้นทางเพิ่มเติมแบบไดนามิก ยืดหยุ่นสำหรับการรวมหลายแหล่ง
  • Deep Merge แบบ recursive: จัดการออบเจกต์ที่ซ้อนกันหลายชั้นอย่างชาญฉลาด จัดการคอนฟลิกต์ที่ leaf node ตามกลยุทธ์ที่กำหนด คงฟิลด์ที่ถูกต้องทั้งหมดไว้
  • แก้ไขคอนฟลิกต์อย่างยืดหยุ่น: คอนฟลิกต์ระดับบนสุดดำเนินการตามกลยุทธ์ที่เลือก; คอนฟลิกต์ออบเจกต์ที่ซ้อนกันจะเข้าสู่การรวมระดับลึก; คอนฟลิกต์อาร์เรย์จัดการแยกตาม arrayConcat/arrayReplace
  • ผลลัพธ์จัดรูปแบบเป็นหนึ่งเดียว: ผลลัพธ์การรวมแสดงด้วยการเยื้อง 2 ช่องว่าง สะดวกสำหรับการตรวจสอบด้วยตนเองและคัดลอกไปยังเครื่องมือถัดไปโดยตรง
  • รวมแบบเรียลไทม์: วางเสร็จแล้วคลิก「รวม」จะได้ผลลัพธ์ทันที หากมีข้อผิดพลาดจะแสดงหมายเลขบรรทัด JSON และข้อความแสดงข้อผิดพลาดโดยละเอียด
  • ประมวลผลในเครื่องเพื่อความเป็นส่วนตัว: การแยกวิเคราะห์ การรวม และการจัดรูปแบบทั้งหมดเสร็จสิ้นในเบราว์เซอร์แบบโลคัล เนื้อหาที่ป้อนจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ใดๆ
  • เชื่อมต่อกับเครื่องมือถัดไปอย่างไร้รอยต่อ: ผลลัพธ์การรวมสามารถคัดลอกไปยังเครื่องมือจัดรูปแบบ JSON ตรวจสอบ Schema สร้างโค้ด ฯลฯ เพื่อดำเนินการต่อในคลิกเดียว

ตัวอย่างโค้ด

ใช้ lodash merge สำหรับ JavaScript Deep Merge

javascript
// npm install lodash.merge
import merge from 'lodash.merge';

const a = { user: { name: 'Alice', age: 28 }, tags: ['admin'] };
const b = { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] };

// Deep Merge: ออบเจกต์ที่ซ้อนกันถูกรวมแบบ recursive, leaf node ค่าที่ป้อนทีหลังทับค่าก่อนหน้า
const deep = merge({}, a, b);
console.log(deep);
// => { user: { name: 'Alice', age: 29, email: 'a@x.com' }, tags: ['admin', 'editor'] }

// Shallow Merge: คีย์ระดับบนสุดทับทั้งบล็อก ไม่ลงไปในระดับที่ซ้อนกัน
const shallow = Object.assign({}, a, b);
console.log(shallow);
// => { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] }

ใช้ mergedeep สำหรับ Python Deep Merge

python
# pip install mergedeep
from mergedeep import merge

a = {"user": {"name": "Alice", "age": 28}, "tags": ["admin"]}
b = {"user": {"email": "a@x.com", "age": 29}, "tags": ["editor"]}

# Deep Merge
result = merge(a, b)
print(result)
# => {'user': {'name': 'Alice', 'age': 29, 'email': 'a@x.com'}, 'tags': ['admin', 'editor']}

# หมายเหตุ: mergedeep ค่าเริ่มต้นจะรวมอาร์เรย์ สตริง/ตัวเลขจะถูกทับ
# หากต้องการทับอาร์เรย์ ให้เพิ่ม strategy='override'

ใช้ jq -s รวม JSON หลายไฟล์บนบรรทัดคำสั่ง

bash
# รวมอาร์เรย์ JSON หลายชุดเป็นอาร์เรย์ยาวหนึ่งเดียว
jq -s 'add' a.json b.json c.json

# รวมออบเจกต์ JSON หลายรายการแบบ recursive (jq 1.6+)
jq -s 'reduce .[] as $item ({}; . * $item)' a.json b.json

# Shallow Merge: ทับคีย์ระดับบนสุดของ b ลงบน a
jq -s '.[0] * .[1]' a.json b.json

# หลังจากรวมอาร์เรย์ คงไว้เฉพาะฟิลด์ id ที่ไม่ซ้ำกัน
jq -s '[.[].items[]] | unique_by(.id)' a.json b.json

คำถามที่พบบ่อย

การรวม JSON และการต่อ JSON เป็นสิ่งเดียวกันหรือไม่?

ไม่เหมือนกันทีเดียว "การต่อ" มักหมายถึงการนำสตริงมาต่อกันโดยตรง ไม่มีโครงสร้าง; "การรวม" หมายถึงการรวมออบเจกต์หลายรายการเข้าด้วยกันแบบ recursive ตามโครงสร้าง JSON จะมีการจัดการคอนฟลิกต์ของชื่อคีย์ เครื่องมือนี้หมายถึงอย่างหลัง — การรวม JSON แบบมีโครงสร้าง

ควรเลือก Deep Merge หรือ Shallow Merge อย่างไร?

Shallow Merge: ประมวลผลเฉพาะคีย์ระดับบนสุด คีย์ที่ชื่อซ้ำกันจะถูกทับทั้งบล็อก คล้าย `Object.assign` ง่ายและตรงไปตรงมา Deep Merge: ลง recursive เข้าไปในออบเจกต์ที่ซ้อนกัน รวมแต่ละ leaf node แยกกัน ชาญฉลาดกว่า หาก JSON หลายรายการของคุณเพิ่มฟิลด์ในพาธย่อยต่างกัน (เช่น base.user.name กับ override.user.email) ให้ใช้ Deep Merge; หากต้องการทับออบเจกต์ย่อยทั้งหมดในคราวเดียว ให้ใช้ Shallow Merge

เมื่อรวมอาร์เรย์ จะทำตามลำดับหรือตามดัชนี?

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

เมื่อชื่อคีย์ชนกัน จะตัดสินว่าใครทับใครอย่างไร?

ตัดสินตามลำดับการป้อน: JSON ที่ป้อนทีหลังจะทับคีย์ที่ชื่อซ้ำกันของ JSON ก่อนหน้า (ทับทั้งบล็อกภายใต้กลยุทธ์ Shallow/Array Replace ทับเฉพาะ leaf node ภายใต้ Deep Merge) หากต้องการให้ "ค่าที่ป้อนก่อนมีความสำคัญกว่า" เพียงสลับลำดับการป้อน

รองรับการรวม JSON อาร์เรย์หรือไม่?

รองรับ มีสองสถานการณ์ที่พบบ่อย: ① หลาย JSON เป็นอาร์เรย์ทั้งหมด → ใช้ "arrayConcat" ต่อเป็นอาร์เรย์ยาวหนึ่งเดียว; ② หลาย JSON เป็นออบเจกต์ทั้งหมด โดยมีบางฟิลด์เป็นอาร์เรย์ → ใช้ "arrayConcat" เพื่อรวมอาร์เรย์หลายชุด หรือใช้ "arrayReplace" เพื่อให้ค่าที่ป้อนทีหลังมีผล

สามารถรวม JSON มากกว่า 2 รายการพร้อมกันได้หรือไม่?

ได้ มีช่องป้อนค่า 2 ช่องโดยค่าเริ่มต้น คลิกปุ่ม「+」สามารถเพิ่มช่องป้อนค่าเพิ่มเติมแบบไดนามิก; ข้อมูลที่ป้อนทั้งหมดจะถูกรวมตามลำดับจากบนลงล่าง โดยทฤษฎีไม่จำกัดจำนวน แต่หน่วยความจำของเบราว์เซอร์จะจำกัดขนาดของแต่ละส่วน

ลำดับคีย์หลังจากรวมถูกกำหนดอย่างไร?

Deep Merge: ลำดับคีย์ของ JSON แรกมีความสำคัญก่อน คีย์ใหม่จาก JSON ที่สองจะถูกเพิ่มต่อท้ายของระดับที่เกี่ยวข้อง Shallow Merge: ตามลำดับการป้อน คีย์ทั้งหมดของ JSON แรกจะปรากฏก่อน คีย์ใหม่จาก JSON ถัดไปจะถูกเพิ่มต่อท้ายที่ระดับบนสุด; คีย์ที่ชื่อซ้ำกันจะคงลำดับของ JSON แรกไว้ไม่เปลี่ยนแปลง

เครื่องมือจะแก้ไขชนิดข้อมูลของฟิลด์หรือไม่?

จะไม่แก้ไขชนิดข้อมูลโดยเจตนา หากภายใต้กลยุทธ์ Shallow/Array Replace คีย์ที่ชื่อซ้ำกันของ JSON ทั้งสองข้างหนึ่งเป็นออบเจกต์ อีกข้างหนึ่งเป็นอาร์เรย์ จะทับโดยตรงตามหลักการ "ค่าที่ป้อนทีหลังมีผล" และจะไม่ทำการแปลงชนิดข้อมูล Deep Merge จะทำ recursive เฉพาะเมื่อ "ทั้งสองข้างเป็น plain object" กรณีอื่นๆ ทั้งหมดจะถูกจัดการแบบทับค่า

สามารถคงค่า null ไว้ได้หรือไม่?

ได้ null เป็นค่าที่ถูกกฎหมายใน JSON เครื่องมือนี้จะถือว่า null เป็นค่า leaf ธรรมดา: เมื่อ Shallow/Array Replace null ที่ป้อนทีหลังจะทับค่าก่อนหน้า; เมื่อ Deep Merge เมื่อพบ null จะถูกจัดการตามกฎการทับ จะไม่ถูกข้ามเป็นพิเศษ

หลังจากรวม จะแสดงข้อมูลสถิติหรือไม่?

มี พื้นที่ผลลัพธ์จะแสดงจำนวนส่วน JSON ที่เข้าร่วมการรวมและจำนวนคีย์ทั้งหมด สะดวกสำหรับการตรวจสอบผลลัพธ์อย่างรวดเร็ว; สำหรับรายการฟิลด์โดยละเอียด กรุณาดูผลลัพธ์ที่จัดรูปแบบทางด้านขวาโดยตรง

เครื่องมือจะอัปโหลด JSON ของฉันไปยังเซิร์ฟเวอร์หรือไม่?

ไม่ การแยกวิเคราะห์ การรวม และการจัดรูปแบบทั้งหมดเสร็จสิ้นในเบราว์เซอร์แบบโลคัล ข้อมูลที่ป้อนและผลลัพธ์ระหว่างทางจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ใดๆ สามารถใช้งานแบบออฟไลน์ได้ เหมาะสำหรับการประมวลผล JSON หลายแหล่งที่มีข้อมูลละเอียดอ่อน (เช่น คอนฟิกสภาพแวดล้อมการผลิต การตอบสนอง API ภายใน)

ลำดับที่ดีที่สุดเมื่อใช้ร่วมกับจัดรูปแบบ JSON และตรวจสอบ Schema คืออะไร?

สายงานที่แนะนำ: ① ซ่อมแซม JSON (ทำความสะอาด JSON ที่ไม่ถูกกฎหมาย) → ② เครื่องมือรวม JSON นี้ (รวมหลายแหล่ง) → ③ จัดรูปแบบ JSON (ทำการเยื้องให้เป็นหนึ่งเดียว) → ④ ตรวจสอบ JSON Schema (ตรวจสอบโครงสร้างสุดท้าย) → ⑤ สร้างโค้ดในขั้นตอนถัดไป (TypeScript / Java / Go ฯลฯ) เลือกทำเพียงบางขั้นตอนตามความจำเป็นก็ได้

การแก้ไขปัญหา

การรวมแจ้ง "Unexpected token" หรือ "Invalid JSON"

สาเหตุ: มี JSON อย่างน้อยหนึ่งช่องป้อนค่าที่ไม่ถูกกฎหมาย วิธีแก้ไข: วาง JSON ที่ผิดพลาดลงในเครื่องมือ「ซ่อมแซม JSON」เพื่อทำความสะอาดก่อน (จัดการจุลภาคท้าย เครื่องหมายคำพูดเดี่ยว คีย์ที่ไม่มีเครื่องหมายคำพูด ฯลฯ โดยอัตโนมัติ) แล้วกลับมาที่เครื่องมือนี้เพื่อรวม; หรือตรวจสอบว่าลืมใส่วงเล็บปีกกา / วงเล็บเหลี่ยมชั้นนอกหรือไม่

บางฟิลด์ไม่ปรากฏหลังจากรวม

สาเหตุ: ภายใต้กลยุทธ์ Shallow/Array Replace คีย์ที่ชื่อซ้ำกันถูกทับทั้งบล็อกด้วยค่าที่ป้อนทีหลัง; ภายใต้ Deep Merge ฟิลด์ที่เป็นค่า null ก็จะทับออบเจกต์ก่อนหน้าเช่นกัน วิธีแก้ไข: สลับกลยุทธ์เป็น「Deep Merge」แล้วดูทีละชั้น; หากยืนยันว่า null ที่ป้อนทีหลังเป็นตัวทับ ให้ลบฟิลด์ null ออกจาก JSON ที่ป้อนทีหลังหรือแทนที่ด้วยค่าตัวยึดตำแหน่ง

อาร์เรย์ถูกทับแทนที่จะถูกต่อเข้าด้วยกัน

สาเหตุ: กลยุทธ์ปัจจุบันคือ「Shallow Merge」หรือ「Array Replace」 วิธีแก้ไข: สลับไปที่「Array Concat (ต่ออาร์เรย์)」ในดรอปดาวน์ของแถบเครื่องมือ; หรือรวมอาร์เรย์ทั้งสองเป็นหนึ่งเดียวด้วยตนเองก่อนแล้วจึงรวม

ในผลลัพธ์ Deep Merge ออบเจกต์กลายเป็นอาร์เรย์หรือในทางกลับกัน

สาเหตุ: JSON ทั้งสองมีชนิดข้อมูลไม่ตรงกัน "ออบเจกต์ vs อาร์เรย์" ที่พาธชื่อเดียวกัน เมื่อ Deep Merge พบชนิดข้อมูลไม่ตรงกันจะใช้หลักการ "ค่าที่ป้อนทีหลังมีผล" วิธีแก้ไข: ทำให้ชนิดข้อมูลของทั้งสองข้างเป็นหนึ่งเดียว (เปลี่ยนเป็นออบเจกต์ทั้งคู่หรืออาร์เรย์ทั้งคู่) หรือเปลี่ยนไปใช้กลยุทธ์ Shallow/Array Replace เพื่อกำหนดความหมายอย่างชัดเจน

ลำดับคีย์หลังจากรวมไม่เป็นระเบียบ

สาเหตุ: คีย์ใหม่จาก JSON ที่สองจะถูกเพิ่มต่อท้าย JSON แรกตาม "ตำแหน่งที่แทรก" เบราว์เซอร์/ตัวแยกวิเคราะห์จะจัดเรียงคีย์ที่เป็นจำนวนเต็มบริสุทธิ์ตามตัวเลขโดยอัตโนมัติ วิธีแก้ไข: ใช้เครื่องมือ「จัดเรียง JSON」ทำให้ลำดับชื่อคีย์เป็นหนึ่งเดียวกับ JSON ที่ป้อนทั้งหมดก่อน แล้วจึงรวม; หรือจัดเรียงอีกครั้งก่อนใช้ผลลัพธ์

การรวมไฟล์ขนาดใหญ่ (10 MB+) ค้าง

สาเหตุ: การใช้ JSON.parse กับข้อความขนาดใหญ่หลายส่วนพร้อมกันในเบราว์เซอร์จะใช้หน่วยความจำจำนวนมาก วิธีแก้ไข: ควบคุมข้อมูลที่ป้อนแต่ละส่วนให้อยู่ในช่วง 1-2 MB; ใช้สคริปต์ Node.js (lodash.merge) หรือ Python (mergedeep) ในเครื่องเพื่อประมวลผลไฟล์ขนาดใหญ่พิเศษ; หลังจากประมวลผลเสร็จแล้วใช้เครื่องมือนี้ทำการตรวจสอบเล็กน้อย

อภิธานศัพท์

JSON Merge
การดำเนินการที่รวมออบเจกต์ JSON ตั้งแต่สองรายการขึ้นไปเป็นออบเจกต์ใหม่ตามกฎที่กำหนด จุดสำคัญที่สุดคือ "กลยุทธ์การแก้ไขเมื่อชื่อคีย์ชนกัน"
Deep Merge / การรวมเชิงลึก
กลยุทธ์ที่ลง recursive เข้าไปในออบเจกต์ที่ซ้อนกันและรวมแต่ละ leaf node แยกกัน; เมื่อทั้งสองข้างเป็น plain object จะทำ recursive มิฉะนั้นจะทับค่า
Shallow Merge / การรวมตื้น
กลยุทธ์ที่รวมเฉพาะคีย์ระดับบนสุด คีย์ที่ชื่อซ้ำกันจะถูกทับทั้งบล็อก; ใน JS เทียบเท่ากับ `Object.assign({}, a, b)`
Array Concat / การต่ออาร์เรย์
กลยุทธ์การรวมอาร์เรย์แบบหนึ่ง: รวมอาร์เรย์หลายชุดเป็นอาร์เรย์ยาวหนึ่งเดียวโดยคงลำดับองค์ประกอบทั้งหมด; มักใช้สำหรับการรวม API response
Array Replace / การแทนที่อาร์เรย์
กลยุทธ์การรวมอาร์เรย์แบบหนึ่ง: อาร์เรย์ที่ชื่อซ้ำกันจะถูกทับทั้งบล็อกด้วยค่าที่ป้อนทีหลัง; มักใช้สำหรับการครอบคลุมคอนฟิก
Object.assign
เมธอดในตัวของ JavaScript ที่คัดลอก enumerable own properties ทั้งหมดจากออบเจกต์ต้นทางตั้งแต่หนึ่งรายการขึ้นไปไปยังออบเจกต์เป้าหมายแบบ shallow copy; เป็นการนำไปใช้มาตรฐานของการรวมตื้น
lodash.merge
ฟังก์ชัน Deep Merge ที่ให้มาโดยไลบรารี Lodash เป็นการนำไปใช้ deep merge ที่ใช้กันมากที่สุดในระบบนิเวศ Node.js; อาร์เรย์จะถูกรวมกันแทนที่จะถูกทับ
mergedeep (Python)
ไลบรารี Deep Merge ในระบบนิเวศ Python ติดตั้งด้วย pip install mergedeep; รองรับพารามิเตอร์ strategy เพื่อควบคุมพฤติกรรมการรวม/การทับอาร์เรย์
jq -s 'add'
คำสั่ง jq สำหรับรวมอาร์เรย์ JSON หลายชุดเป็นอาร์เรย์เดียว; การรวมออบเจกต์ JSON หลายรายการต้องใช้ `reduce .[] as $item ({}; . * $item)`
BFF (Backend for Frontend)
ชั้นการรวมที่อยู่ระหว่างฟรอนต์เอนด์และแบ็กเอนด์เซอร์วิสในสถาปัตยกรรมไมโครเซอร์วิส; มักต้องรวม JSON response จากหลายเซอร์วิสเป็น response เดียว เป็นสถานการณ์คลาสสิกของ JSON Merge

เปรียบเทียบกลยุทธ์การรวม JSON 4 แบบ

กลยุทธ์ขอบเขตการทำงานการจัดการอาร์เรย์สถานการณ์ที่พบบ่อย
Deep Merge (เชิงลึก)recursive ทุกระดับที่ซ้อนกันตาม arrayConcat/arrayReplace ที่เลือกแบ่งชั้นคอนฟิกหลายสภาพแวดล้อม รวมพจนานุกรม i18n
Shallow Merge (ตื้น)รวมเฉพาะระดับบนสุดทับทั้งบล็อกการทับแบบง่ายสไตล์ Object.assign
Array Concat (ต่ออาร์เรย์)ระดับบนสุดต่อเป็นอาร์เรย์ใหม่รวม API แบบแบ่งหน้า รวม mock data
Array Replace (แทนที่อาร์เรย์)ระดับบนสุดค่าที่ป้อนทีหลังมีผลครอบคลุมคอนฟิก Feature Flag

ตารางเปรียบเทียบการนำไปใช้รวม JSON ที่พบบ่อย

การนำไปใช้/ไลบรารีภาษาพฤติกรรมเริ่มต้นหมายเหตุ
Object.assignJavaScriptShallow Mergeไลบรารีมาตรฐาน ES2015; หลัง ES2017 สามารถใช้ `Object.assign({}, a, b)`
{ ...a, ...b }JavaScriptShallow Mergeตัวดำเนินการ spread ใช้งานกระชับกว่า
lodash.mergeJavaScriptDeep Mergeอาร์เรย์ถูกรวมกันไม่ทับ ติดตั้งด้วย npm install lodash.merge
mergedeepPythonDeep Mergestrategy='override' เปลี่ยนการรวมอาร์เรย์เป็นการทับ
deepmerge (Python)PythonDeep Mergeการนำไปใช้ยอดนิยมอีกตัว ติดตั้งด้วย pip install deepmerge
jq -s 'add'Shellรวมอาร์เรย์การรวมออบเจกต์ต้องใช้ `reduce .[] as $i ({}; . * $i)`

Authoritative References