ซ่อมแซม JSON

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

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

การซ่อมแซม JSON (JSON Repair) คืออะไร?

การซ่อมแซม JSON (JSON Repair) คือกระบวนการแปลงข้อความ JSON ที่ไม่ได้มาตรฐานซึ่งไม่สามารถประมวลผลโดยตัวแยกวิเคราะห์ JSON แบบเข้มงวดเนื่องจากข้อผิดพลาดทางไวยากรณ์ ให้กลับเป็นสตริง JSON ที่ถูกต้องตาม RFC 8259 โดยอัตโนมัติ ซึ่งแตกต่างจาก 'การจัดรูปแบบ JSON (Beautify)' การซ่อมแซม JSON ไม่ได้จัดการกับความแตกต่างด้านรูปแบบแต่เป็นข้อผิดพลาดเชิงโครงสร้าง: คอมม่าท้าย อัญประกาศเดี่ยว อัญประกาศหาย วงเล็บไม่ปิด ตัวห่อ Markdown คอมเมนต์ — ทั้งหมดนี้ทำให้ JSON.parse() โยน SyntaxError โดยตรง แต่พบได้บ่อยมากในการพัฒนาจริง

แหล่งที่มาของ JSON ที่ 'ไม่ได้มาตรฐาน' ในโครงการวิศวกรรมจริงมีความเข้มข้นสูง: ① เมื่อคัดลอกจาก LLM เช่น ChatGPT / Claude / Gemini ผลลัพธ์มักถูกห่อด้วยบล็อกโค้ด Markdown (```json ... ```) หรือมาพร้อมข้อความอธิบาย; ② การคัดลอกจาก console.log() ของออบเจกต์ JavaScript อาจมีคอมม่าท้ายและอัญประกาศเดี่ยว; ③ ไฟล์การกำหนดค่ามักใช้ไวยากรณ์ขยาย JSON5 / JSONC (อนุญาตคอมเมนต์ คีย์ไม่มีอัญประกาศ สตริงหลายบรรทัด ฯลฯ); ④ การตอบสนองแบบสตรีมหรือการตัดล็อกอาจทำให้ JSON ขาดกลางทาง ขาด `}` หรือ `"` ปิดท้าย เครื่องมือซ่อมแซม JSON จะสแกนข้อความอินพุต ระบุปัญหาทั่วไปเหล่านี้ และกู้คืนเนื้อหาเป็น JSON มาตรฐานตามหลักการ 'การแทรกแซงน้อยที่สุด' ในขณะที่รักษาความหมายของข้อมูลต้นฉบับให้มากที่สุด

ในระดับการนำไปใช้ การซ่อมแซม JSON โดยทั่วไปประกอบด้วยสองขั้นตอน: ① การแยกวิเคราะห์แบบยอมรับได้ (tolerant parse) — ใช้ตัวสแกนที่อิงตามเครื่องสถานะแทนการจับคู่ regex เพื่อประมวลผลสตรีมอักขระทีละขั้นตอน แยกแยะอักขระไวยากรณ์ 'ภายในสตริง' และ 'ภายนอกสตริง'; ② ผลลัพธ์แบบมาตรฐาน (canonical output) — สร้างใหม่ด้วย `JSON.parse` + `JSON.stringify` เพื่อให้แน่ใจว่าผลลัพธ์ถูกต้อง 100% สำหรับตัวแยกวิเคราะห์แบบเข้มงวดใดๆ เครื่องมือซ่อมแซม JSON ของ GeekFormat ดำเนินการซ่อมแซมทั้งหมดในเบราว์เซอร์ ไม่เคยส่งเนื้อหาต้นฉบับไปยังเซิร์ฟเวอร์ใดๆ เหมาะสำหรับการประมวลผลการตอบสนอง API ที่ละเอียดอ่อน ไฟล์การกำหนดค่าภายใน และผลลัพธ์ของโมเดล AI

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

  • การทำความสะอาดผลลัพธ์ AI/LLM: แปลง JSON ที่มีตัวห่อ Markdown ข้อความอธิบาย และคอมม่าท้ายจาก ChatGPT/Claude เป็น JSON มาตรฐานในคลิกเดียว
  • การดีบักและแก้ไขปัญหา API: เมื่อการตอบสนอง API ถูกตัดเนื่องจากปัญหาเกตเวย์หรือเครือข่าย เติมวงเล็บและสตริงอย่างรวดเร็วเพื่อระบุโครงสร้างข้อมูลต้นฉบับ
  • ลิเทอรัลออบเจกต์ JavaScript ที่คัดลอกจากคอนโซล: แก้ไขอัญประกาศเดี่ยว คอมม่าท้าย และชื่อคีย์ไม่มีอัญประกาศในที่เดียว
  • การทำความสะอาดไฟล์การกำหนดค่า: ลบคอมเมนต์จาก JSON5/JSONC เพื่อรับ JSON มาตรฐาน พร้อมสำหรับการเชื่อมต่อกับบริการปลายทางอย่างเป็นหนึ่งเดียว
  • การซ่อมแซมข้อมูลล็อกและคลิปบอร์ด: ทำให้ส่วนย่อย JSON ที่มีคอมเมนต์ ช่องว่างพิเศษ หรือการตัดเป็นมาตรฐานอย่างรวดเร็ว
  • การย้ายข้อมูลและการประมวลผลล่วงหน้าด้วยสคริปต์: เพิ่มขั้นตอนการซ่อมแซมในไปป์ไลน์การย้ายข้อมูลเพื่อป้องกันไม่ให้ JSON ที่ไม่ถูกต้องจำนวนน้อยบล็อกชุด ETL ทั้งหมด

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

  1. วางเนื้อหา JSON ที่มีข้อผิดพลาด มีตัวห่อ Markdown หรือถูกตัดลงในกล่องอินพุตด้านซ้าย หรือคลิก 'ตัวอย่าง' เพื่อโหลด JSON ที่เสียหายทั่วไป หรืออัปโหลดไฟล์ .json/.txt
  2. เครื่องมือตรวจจับและแก้ไขปัญหาทางไวยากรณ์ทั่วไปโดยอัตโนมัติ พื้นที่ผลลัพธ์ด้านขวาแสดง JSON มาตรฐานที่จัดรูปแบบแล้วและจำนวนปัญหาที่ซ่อมแซมแต่ละประเภท
  3. หากยังมีข้อความข้อผิดพลาดสีแดง คุณสามารถแก้ไขอินพุตด้วยตนเองและเรียกใช้การซ่อมแซมอีกครั้ง (Mac: ⌘+Shift+R, Windows: Ctrl+Shift+R)
  4. หลังจากยืนยันว่าโครงสร้างถูกต้อง คลิก 'คัดลอก' เพื่อนำผลลัพธ์ที่ซ่อมแซมแล้วไปยังคลิปบอร์ด หรือคลิก 'ดาวน์โหลด' เพื่อบันทึกเป็น repaired.json สำหรับการจัดรูปแบบ การตรวจสอบ ฯลฯ เพิ่มเติม

คุณสมบัติ

  • ครอบคลุมข้อผิดพลาดทางไวยากรณ์ทั่วไป 7 ประเภท: คอมม่าท้าย อัญประกาศเดี่ยว คีย์ไม่มีอัญประกาศ สตริงไม่ปิด คอมเมนต์ วงเล็บหาย ตัวห่อบล็อกโค้ด Markdown
  • ปรับให้เหมาะสำหรับการทำความสะอาดผลลัพธ์ AI: ลบตัวห่อ ```json และข้อความอธิบายนอกบล็อกโค้ดโดยอัตโนมัติ รู้จำผลลัพธ์ทั่วไปของ ChatGPT, Claude, Gemini และ LLM อื่นๆ
  • เข้ากันได้กับ JSON5/JSONC: แยกวิเคราะห์ไวยากรณ์ขยายรวมถึงคอมเมนต์ อัญประกาศแบบหลวม และช่องว่างพิเศษ (เช่น อักขระ Unicode ที่มองไม่เห็น)
  • การเติมเต็ม JSON ที่ถูกตัดอย่างชาญฉลาด: จัดการการตอบสนอง API ที่ถูกตัดและวงเล็บปิดที่หายไปโดยการเติมวงเล็บและอัญประกาศที่ขาดหายโดยอัตโนมัติ
  • การแสดงภาพปัญหาการซ่อมแซม: นับและแสดงจำนวนครั้งที่ปัญหาแต่ละประเภทได้รับการซ่อมแซมโดยอัตโนมัติ สะดวกสำหรับการตรวจสอบและทบทวนด้วยตนเอง
  • การประมวลผลในเครื่องเพื่อความเป็นส่วนตัว: การแยกวิเคราะห์ การซ่อมแซม และการจัดรูปแบบทั้งหมดเกิดขึ้นในเบราว์เซอร์ เนื้อหาอินพุตไม่ถูกส่งไปยังเซิร์ฟเวอร์ใดๆ
  • การส่งต่อที่ราบรื่นสู่การจัดรูปแบบ: JSON มาตรฐานที่ซ่อมแซมแล้วสามารถเข้าสู่การจัดรูปแบบ JSON การตรวจสอบ Schema และการสร้างโค้ดได้ในคลิกเดียว
  • โหลดไฟล์และตัวอย่าง: รองรับการอัปโหลดไฟล์ .json/.txt หรือคลิกโหลดตัวอย่างเพื่อตรวจสอบผลการซ่อมแซมอย่างรวดเร็ว

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

การซ่อมแซมแบบโปรแกรมด้วยไลบรารี JavaScript jsonrepair

javascript
// npm install jsonrepair
import { jsonrepair } from 'jsonrepair';

const broken = `{
  name: 'Alice',
  age: 30,
  tags: ['dev', 'writer',], // trailing comma + comment
}`;

try {
  const fixed = jsonrepair(broken);
  const obj = JSON.parse(fixed);
  console.log(obj);
  // => { name: 'Alice', age: 30, tags: ['dev', 'writer'] }
} catch (err) {
  console.error('Still unrepairable:', err.message);
}

การซ่อมแซมแบบโปรแกรมด้วยไลบรารี Python jsonrepair

python
# pip install jsonrepair
from jsonrepair import jsonrepair
import json

broken = '''{
  name: "Alice",
  age: 30,
  tags: ["dev", "writer",], // trailing comma + comment
}'''

fixed = jsonrepair(broken)
obj = json.loads(fixed)
print(obj)
# => {'name': 'Alice', 'age': 30, 'tags': ['dev', 'writer']}

การแก้ไขคอมม่าท้ายอย่างรวดเร็วด้วย jq + sed (ใช้ในกรณีฉุกเฉินเท่านั้น)

bash
# ลบคอมม่าท้ายจากออบเจกต์/อาร์เรย์ (ตัวเลือกฉุกเฉิน ไม่จัดการคอมเมนต์ / อัญประกาศเดี่ยว)
# สำหรับสถานการณ์ซับซ้อน ใช้ไลบรารีเฉพาะเช่น jsonrepair
sed -E 's/,([ \t]*[}\]])/\1/g' broken.json > clean.json

# ตรวจสอบผลลัพธ์ที่ซ่อมแซมแล้ว
jq . clean.json >/dev/null && echo 'JSON is valid'

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

การซ่อมแซม JSON กับการจัดรูปแบบ JSON แตกต่างกันอย่างไร?

การจัดรูปแบบ JSON เพียงจัดรูปแบบ JSON ที่ถูกต้องแล้วแต่มีการเยื้องหรือช่องว่างไม่สอดคล้องกันใหม่ ในทางกลับกัน การซ่อมแซม JSON จัดการ JSON ที่มีข้อผิดพลาดทางไวยากรณ์โดยเฉพาะ: แก้ไขปัญหาเชิงโครงสร้างเช่นคอมม่าท้าย อัญประกาศเดี่ยว คอมเมนต์ และวงเล็บหายก่อน แล้วจึงแสดงผลในรูปแบบมาตรฐาน เมื่อเครื่องมือจัดรูปแบบโยน SyntaxError คุณควรใช้การซ่อมแซม JSON ก่อน

เครื่องมือรองรับการแก้ไขข้อผิดพลาดทางไวยากรณ์ JSON ทั่วไปอะไรบ้าง?

เครื่องมือมีอัลกอริทึมการซ่อมแซมอัจฉริยะสำหรับปัญหาที่พบบ่อยต่อไปนี้: 1) คอมม่าท้าย (Trailing comma); 2) อัญประกาศเดี่ยวแทนอัญประกาศคู่; 3) ชื่อคีย์ไม่มีอัญประกาศ; 4) สตริงไม่ปิด; 5) มีคอมเมนต์บรรทัด/บล็อก JavaScript; 6) JSON ที่ถูกห่อในบล็อกโค้ด Markdown; 7) วงเล็บปีกกา/เหลี่ยมปิดหายเนื่องจากการตัดท้าย

ทำไม JSON ที่ส่งออกจาก AI หรือ LLM จึงมักไม่ได้มาตรฐาน?

โมเดลภาษาขนาดใหญ่ (เช่น ChatGPT, Claude, Gemini) มักสร้าง JSON ที่มีตัวห่อ Markdown (```json ... ```) ข้อความอธิบายนำ/ตาม คอมม่าท้าย คอมเมนต์ หรือโครงสร้างไม่สมบูรณ์เนื่องจากการตัดโทเค็น การซ่อมแซม JSON ถูกปรับให้เหมาะสำหรับสถานการณ์เหล่านี้โดยเฉพาะ — ทำความสะอาดผลลัพธ์ AI เป็น JSON ที่ถูกต้องในคลิกเดียว

JSON ที่ซ่อมแซมแล้วมีโครงสร้างเหมือนกับข้อมูลต้นฉบับเสมอหรือไม่?

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

ทำไมไม่ใช้ Python json.loads หรือ JavaScript JSON.parse โดยตรง?

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

คอมเมนต์ใน JSON5 / JSONC จะถูกรักษาไว้หรือไม่?

ไม่ คอมเมนต์เป็นส่วนหนึ่งของไวยากรณ์ขยาย JSON5 ไม่ใช่ JSON มาตรฐาน เครื่องมือจะลบออกเพื่อให้แน่ใจว่าผลลัพธ์เป็นไปตาม JSON มาตรฐาน หากคุณต้องการเก็บคอมเมนต์ไว้ ให้ใช้ไฟล์ต้นฉบับ JSON5 หรือเชนเครื่องมือ JSONC ต่อไป หากคุณต้องการแปลง JSON5 เป็น JSON มาตรฐาน เครื่องมือนี้ทำได้โดยตรง

JSON ที่ถูกตัด (เช่น ผลลัพธ์สตรีมถูกตัดกลางทาง) สามารถซ่อมแซมได้หรือไม่?

ได้ เครื่องมือพยายามจับคู่วงเล็บปิด วงเล็บเหลี่ยม และอัญประกาศปิดสตริงที่ขาดหาย ในขณะที่รักษาเนื้อหาที่รู้จำได้มากที่สุด หมายเหตุ: หากจุดตัดอยู่ในลิเทอรัลสตริง คุณอาจต้องเติมอักขระสำคัญด้วยตนเอง

หลังการซ่อมแซมจะมีการสูญหายของข้อมูลหรือไม่?

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

สามารถซ่อมแซม JSON หลายรายการแบบกลุ่มได้หรือไม่?

เครื่องมือนี้ซ่อมแซมครั้งละหนึ่งอินพุต สำหรับสถานการณ์แบบกลุ่ม แนะนำให้รันอัลกอริทึมพื้นฐานในเครื่องด้วยสคริปต์ (เช่น ไลบรารี jsonrepair ของ Python หรือแพ็กเกจ npm josdejong/jsonrepair) ก่อน แล้วนำผลลัพธ์เข้าเครื่องมือนี้เพื่อตรวจสอบด้วยตนเองและจัดรูปแบบ

หลังการซ่อมแซมยังต้องจัดรูปแบบและตรวจสอบ Schema อีกหรือไม่?

แนะนำ การซ่อมแซมแก้ไขข้อผิดพลาดระดับไวยากรณ์เป็นหลัก การจัดรูปแบบและการตรวจสอบ Schema รับประกันความสามารถในการอ่านและความถูกต้องทางธุรกิจ ผลลัพธ์ของเครื่องมือซ่อมแซมเชื่อมต่อกับเครื่องมือจัดรูปแบบ JSON ตัวตรวจสอบ Schema และตัวสร้างโค้ดของ GeekFormat ได้อย่างราบรื่น

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

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

สามารถกำหนดกลยุทธ์การซ่อมแซมที่ใช้แต่ละครั้งได้หรือไม่?

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

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

ข้อผิดพลาด "ไม่สามารถซ่อมแซม JSON นี้ได้"

สาเหตุ: ข้อความอินพุตมีความเสียหายเชิงโครงสร้างอย่างรุนแรง เช่น วงเล็บหายหลายตำแหน่ง ลิเทอรัลสตริงถูกตัด หรือชุดอักขระเสียหาย วิธีแก้ไข: เปิดไฟล์ต้นฉบับในตัวแก้ไขข้อความล้วนก่อน ยืนยันว่าการเข้ารหัสเป็น UTF-8 ไม่มี BOM และไม่ใช่ไบนารีที่บีบอัด หากข้อมูลมาจากการตอบสนอง API ติดต่อต้นทางเพื่อเติมให้สมบูรณ์ สำหรับชุดข้อมูลที่เสียหายอย่างมาก ใช้ไฟล์ต้นฉบับโดยตรง

ฟิลด์ถูกย้ายไปตำแหน่งที่ไม่ถูกต้องหลังการซ่อมแซม

สาเหตุ: ข้อความต้นฉบับมีอักขระไวยากรณ์ JSON (เช่น //, /*, }) ภายในคอมเมนต์หรือลิเทอรัลสตริง ทำให้ตัวแยกวิเคราะห์ตัดสินผิด หรือระดับการซ้อนลึกมากจนการจับคู่วงเล็บคลาดเคลื่อน วิธีแก้ไข: escape // และ /* ภายในสตริงด้วยตนเองด้วยแบ็กสแลช สำหรับข้อมูลที่ซ้อนลึก เพิ่มวงเล็บนอกชั่วคราวหรือขึ้นบรรทัดใหม่ก่อนเรียกใช้การซ่อมแซมอีกครั้ง

ข้อความอธิบายในผลลัพธ์ AI ไม่ถูกลบ

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

ขนาดไม่เปลี่ยนแปลงหลังการซ่อมแซมหรืออักขระบางตัวถูกแทนที่

สาเหตุ: ต้นฉบับมีแบ็กสแลช การ escape Unicode หรือเอนทิตี HTML ซึ่งถูก escape ใหม่โดยเครื่องมือตามกฎ JSON วิธีแก้ไข: ตรวจสอบว่าต้นฉบับซ้อนอยู่ในสตริง JS หรือไม่ หากอยู่ในหน้า HTML ให้ถอดรหัส HTML ก่อน การเพิ่มจำนวนอักขระหลังการ escape เป็นเรื่องปกติ

เบราว์เซอร์แสดง "หน่วยความจำไม่เพียงพอ" หรือหน้าค้าง

สาเหตุ: อินพุตเดี่ยวเกิน 5–10 MB สร้างแรงกดดันหน่วยความจำอย่างมากต่อเบราว์เซอร์ วิธีแก้ไข: แบ่งข้อมูลเป็นชุดย่อย (ชุดละ 1–2 MB) หรือใช้ไลบรารี jsonrepair ฝั่งเซิร์ฟเวอร์สำหรับการประมวลผลแบบสตรีม ความแตกต่างเล็กน้อยระหว่างผลลัพธ์ที่ซ่อมแซมกับต้นฉบับเป็นเรื่องปกติ

หลังการซ่อมแซม การตรวจสอบ Schema ยังคงรายงานข้อผิดพลาด

สาเหตุ: การซ่อมแซม JSON แก้ไขเฉพาะข้อผิดพลาดระดับไวยากรณ์ ไม่ได้ตรวจสอบว่าชื่อฟิลด์ธุรกิจ ประเภท หรือค่าเป็นไปตาม Schema หรือไม่ วิธีแก้ไข: ใช้เครื่องมือตรวจสอบ JSON Schema ของ GeekFormat เพื่อตรวจสอบข้อจำกัดของฟิลด์ ค้นหาฟิลด์เฉพาะตามข้อผิดพลาดและแก้ไขด้วยตนเอง

อภิธานศัพท์

JSON
JavaScript Object Notation รูปแบบการแลกเปลี่ยนข้อมูลน้ำหนักเบาที่อิงตามคู่คีย์-ค่า กำหนดไว้ใน RFC 8259 มาตรฐานโดยพฤตินัยสำหรับ REST API ไฟล์การกำหนดค่า และล็อก
RFC 8259
ข้อกำหนด JSON อย่างเป็นทางการที่เผยแพร่โดย IETF กำหนดไวยากรณ์ที่เข้มงวดของ JSON ที่ถูกต้อง — คีย์ทั้งหมดต้องอยู่ในอัญประกาศคู่ มีเพียงชุดอักขระที่จำกัดในสตริงที่ต้อง escape ไม่อนุญาตคอมเมนต์และคอมม่าท้าย
JSON.parse
ตัวแยกวิเคราะห์ JSON แบบเข้มงวดที่มีใน JavaScript และเบราว์เซอร์สมัยใหม่ ตาม RFC 8259 โยน SyntaxError โดยตรงเมื่อพบข้อผิดพลาดทางไวยากรณ์และไม่สามารถซ่อมแซมแบบยอมรับได้
JSON5
ไวยากรณ์ขยายของ JSON (ไม่เป็นมาตรฐาน) อนุญาตคีย์ไม่มีอัญประกาศ สตริงอัญประกาศเดี่ยว คอมเมนต์ (// และ /* */) คอมม่าท้าย เลขฐานสิบหก ฯลฯ เขียนง่ายกว่าสำหรับมนุษย์แต่เข้ากันไม่ได้กับ JSON.parse
JSONC
JSON with Comments ชื่อทั่วไปที่ใช้โดยตัวแก้ไขเช่น VS Code สำหรับไฟล์การกำหนดค่า JSON ที่มีคอมเมนต์ (เช่น tsconfig.json) โดยแท้จริงแล้วเป็นชื่อเรียกทั่วไปของ JSON5
Trailing Comma / คอมม่าท้าย
คอมม่าเพิ่มเติมหลังจากองค์ประกอบสุดท้ายของออบเจกต์หรืออาร์เรย์ อนุญาตใน JavaScript แต่ถูกห้ามโดยมาตรฐาน JSON — ข้อผิดพลาดทางไวยากรณ์ที่พบบ่อยที่สุดจากผลลัพธ์ LLM และการคัดลอก console.log()
บล็อกโค้ด Markdown
ส่วนของโค้ดที่ห่อด้วย backtick สามตัว (```) LLM มักห่อผลลัพธ์ JSON ใน ```json ... ``` โดยอัตโนมัติ การวางลงใน JSON.parse() โดยตรงจะล้มเหลว
Tolerant Parser / ตัวแยกวิเคราะห์แบบยอมรับได้
ตัวแยกวิเคราะห์ที่สามารถพยายามกู้คืนและดำเนินการแยกวิเคราะห์ต่อเมื่อพบข้อผิดพลาดทางไวยากรณ์ กลไกหลักของเครื่องมือซ่อมแซม JSON แตกต่างจาก JSON.parse แบบเข้มงวด
SyntaxError
ข้อยกเว้นข้อผิดพลาดทางไวยากรณ์ที่โยนโดย JavaScript ตัวแยกวิเคราะห์ JSON แบบเข้มงวดใดๆ จะโยนสิ่งนี้เมื่อได้รับอินพุตที่ไม่เป็นไปตาม RFC 8259
Canonical JSON / JSON มาตรฐาน
JSON ที่สร้างใหม่ผ่าน parse + stringify ด้วยลำดับคีย์ที่เสถียร ไม่มีช่องว่างเกิน และเข้ากันได้ 100% กับตัวแยกวิเคราะห์มาตรฐาน รูปแบบผลลัพธ์สุดท้ายของเครื่องมือซ่อมแซม JSON

ประเภทข้อผิดพลาดการซ่อมแซม JSON ทั่วไปพร้อมตัวอย่าง

หมวดหมู่ข้อผิดพลาดก่อนหลังวิธีการซ่อมแซม
คอมม่าท้าย{ "a": 1, }{ "a": 1 }ลบคอมม่าหลังองค์ประกอบสุดท้าย
อัญประกาศเดี่ยว{ 'a': 1 }{ "a": 1 }แทนที่อัญประกาศเดี่ยวทั้งหมดด้วยอัญประกาศคู่
คีย์ไม่มีอัญประกาศ{ a: 1 }{ "a": 1 }เพิ่มอัญประกาศคู่ให้ชื่อคีย์
คอมเมนต์บรรทัด{ // คอมเมนต์ "a": 1 }{ "a": 1 }ลบบรรทัดคอมเมนต์ // ทั้งหมด
คอมเมนต์บล็อก{ /* บล็อก */ "a": 1 }{ "a": 1 }ลบคอมเมนต์บล็อก /* */
ตัวห่อ Markdown```json { "a": 1 } ```{ "a": 1 }ลบตัวห่อ ```json และ ```
สตริงไม่ปิด{ "a": "hello }{ "a": "hello" }เพิ่มอัญประกาศปิดสตริงที่ขาดหาย
วงเล็บหาย{ "a": 1{ "a": 1 }จับคู่สแต็กเพื่อเพิ่มวงเล็บปีกกา/เหลี่ยมปิดที่ขาดหาย

การซ่อมแซม JSON vs การจัดรูปแบบ JSON vs การตรวจสอบ JSON Schema

เครื่องมือแก้ปัญหาอะไรข้อกำหนดอินพุตโหมดความล้มเหลว
ซ่อมแซม JSONแปลง JSON ที่มีข้อผิดพลาดไวยากรณ์เป็น JSON ที่ถูกต้องยอมรับได้ รับ JSON ที่ไม่ได้มาตรฐานข้อผิดพลาดเมื่อเสียหายเกินกว่าจะเดาโครงสร้างได้
จัดรูปแบบ JSONจัดรูปแบบ JSON ที่ถูกต้องใหม่ต้องเป็น JSON ที่ถูกต้องแล้วSyntaxError ถูกโยนโดยตรง
บีบอัด JSONลบช่องว่าง ลดขนาดต้องเป็น JSON ที่ถูกต้องแล้วSyntaxError ถูกโยนโดยตรง
ตรวจสอบ JSON Schemaตรวจสอบประเภท/ค่าของฟิลด์เทียบกับกฎธุรกิจต้องเป็น JSON ที่ถูกต้องแล้วแสดงรายการกฎที่แต่ละฟิลด์ละเมิด
JSON Merge / Sortรวมหลายแหล่ง / เรียงลำดับคีย์ต้องเป็น JSON ที่ถูกต้องแล้วSyntaxError ถูกโยนโดยตรง

Authoritative References