JSON Toolkit

คู่มือซ่อม JSON: กู้คืนเอาต์พุต LLM ที่พังโดยไม่เสียความเชื่อมั่น

สรุปสำคัญ: เอาต์พุต LLM ที่ถูกห่อด้วย markdown fence มีจุลภาคท้ายและ literal ของ Python ตัว parser เข้มงวดจะปฏิเสธทั้งหมด — ไฟล์คอนฟิกที่แก้มือแล้วขาดเครื่องหมายคำพูดก็เช่นกัน บทความนี้ลากเส้นแบ่งที่แท้จริงระหว่างเก้าชนิดข้อผิดพลาดที่เครื่องมือซ่อมจัดการได้กับสี่ชนิดที่ไม่มีวันซ่อมได้ อธิบายว่าทำไมเครื่องสถานะจึงชนะ regex และส่งมอบห่วงโซ่ parse พร้อมใช้ใน production ด้วย jsonrepair และ json-repair

ระดับกลางอ่านประมาณ 6 นาทีเผยแพร่ 2026-11-08อัปเดต 2026-11-08
แผนภาพไปป์ไลน์ซ่อม JSON: ลอก fence ทำเครื่องหมายคำพูดให้เป็นมาตรฐาน จัดวงเล็บให้สมดุล และตรวจสอบขั้นสุดท้าย

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

หนึ่ง: JSON ที่พังมาจากไหน

การซ่อมไม่ใช่เวทมนตร์ — เริ่มจากดูอินพุตก่อน ในโปรเจกต์จริง JSON ที่ไม่ได้มาตรฐานมาจากสามแหล่งที่กระจุกกัน:

  1. เอาต์พุตของ LLM โมเดลภาษาสร้างข้อความทีละโทเค็น ไม่ได้รัน JSON serializer แม้จะสั่ง "ขอ JSON อย่างเดียว" โมเดลก็ห่อคำตอบด้วย fence ```json แทรก "นี่คือข้อมูลของคุณ" ไว้ข้างหน้า ทิ้งจุลภาคท้าย หรือชนเพดานโทเค็นแล้วหยุดกลางออบเจ็กต์
  2. คัดลอกมาจากภาษาอื่น ออบเจ็กต์ JavaScript ที่พิมพ์ผ่าน console.log มีเครื่องหมายคำพูดเดี่ยวและคีย์ไม่มีเครื่องหมายคำพูด, dictionary ของ Python พิมพ์ออกมาเป็น True/False/None ข้อความที่ "หน้าตาเหมือน JSON" เหล่านี้ระเบิดทันทีที่เจอ JSON.parse
  3. คอนฟิก JSON5/JSONC ไฟล์อย่าง tsconfig ยอมรับคอมเมนต์และจุลภาคท้ายอย่างถูกต้องตามกฎเกณฑ์ เอาไฟล์นั้นไปวางใน parser เข้มงวด — ทั้งไฟล์ถูกปฏิเสธ

สามแหล่งต้องการการจัดการต่างกัน แต่เครื่องมือซ่อมรับได้หมด — ตราบใดที่ข้อผิดพลาดอยู่ในรายการซ่อมได้ที่มันประกาศไว้

สอง: เก้าชนิดข้อผิดพลาดที่เครื่องมือซ่อมซ่อมได้จริง

รวมเอกสารของไลบรารี jsonrepair กับรายการความสามารถที่ผู้ให้บริการเครื่องมือเผยแพร่ ข้อผิดพลาดที่ซ่อมอัตโนมัติได้แบ่งเป็นเก้าชนิด:

ชนิด อินพุตที่พัง ผลหลังซ่อม
จุลภาคท้าย [1, 2, 3,] [1, 2, 3]
เครื่องหมายคำพูดเดี่ยว / โค้ง {'a': 'b'}、{"a": "b"} {"a": "b"}
คีย์ไม่มีเครื่องหมายคำพูด {name: 'Ada'} {"name": "Ada"}
คอมเมนต์ {"a": 1 /* หมายเหตุ */} {"a": 1}
literal ของ Python {"ok": True, "v": None} {"ok": true, "v": null}
markdown fence ```json {...} ``` {...}
จุลภาคขาดหาย [1 2] [1, 2]
วงเล็บ / เครื่องหมายคำพูดไม่ปิด {"a": [1, 2 {"a": [1, 2]}
JSONP / การเชื่อมสตริง cb({...})、"x" + "y" {...}、"xy"

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

  • ตัวเลขที่ขึ้นต้นด้วยศูนย์จะกลายเป็นสตริง 007 ถูกซ่อมเป็น "007" ไม่ใช่ 7 เพื่อไม่ให้หลักหาย ถ้าฟิลด์นั้นเป็นโค้ดข้อความอยู่แล้ว พฤติกรรมนี้ถูกต้อง ถ้าเป็นตัวเลขจริง ๆ การตัดสินเป็นของคุณ
  • คำเปล่า ๆ จะกลายเป็นสตริง NaN ซ่อมเป็นตัวเลขไม่ได้ — บางเจ้าให้ "NaN" บางเจ้าให้ null พฤติกรรมต่างกันตามไลบรารี ทดสอบของคุณก่อนเสียบเข้าไปป์ไลน์
  • อินพุตที่ถูกต้องจะผ่านไปโดยไม่ถูกแตะ เครื่องมือซ่อมที่จริงจังทุกตัวรันเส้นทางเร็วของการ parse เข้มงวดก่อน JSON ที่ถูกต้องไม่เคยเข้าลอจิกการซ่อม จึง "ซ่อมเอกสารดีให้พัง" ไม่ได้

สาม: สี่อย่างที่เครื่องมือซ่อมซ่อมไม่ได้

เส้นแบ่งอีกฝั่งชัดเจนพอ ๆ กัน อย่าหวังการซ่อมสำหรับ:

  1. หน้าข้อผิดพลาด HTML หรือร้อยกรองล้วน ในอินพุตไม่มีโครงสร้าง JSON เลย และไม่มีเครื่องมือใดสร้างข้อมูลจากความว่างเปล่าได้
  2. ข้อมูลที่ถูกต้องตามไวยากรณ์แต่เนื้อหาผิด คีย์สะกดผิด ค่าวางผิดที่ ตัวเลขเก็บเป็นสตริง — นี่เป็นปัญหาเชิงความหมายที่ parser ทุกตัวรวมถึงเครื่องมือซ่อมปล่อยผ่านไปเงียบ ๆ
  3. ข้อมูลที่หายไปเพราะถูกตัดขาด การเติมให้สมบูรณ์เปลี่ยน {"items": [{"id": 1}, {"na เป็น JSON ที่ถูกต้องได้ แต่ค่าของฟิลด์ name ไม่มีวันกลับมา สิ่งที่ได้คือออบเจ็กต์ "ถูกต้องแต่ไม่ครบ" ใน production ตรวจ stopReason === "max_tokens" ก่อนตัดสินใจว่าจะเติมให้สมบูรณ์หรือลองใหม่
  4. คีย์ซ้ำและโครงสร้างกำกวม คีย์ชื่อเดียวกันสองตัวตัวไหนชนะขึ้นกับการใช้งานของ parser เครื่องมือซ่อมที่มีความรับผิดชอบมีโหมด strict ที่โยนข้อผิดพลาด แทนที่จะเลือกข้างหนึ่งเงียบ ๆ

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

สี่: สองสำนักการใช้งาน — URL เดียวปิดข้อถกเถียง

เครื่องมือซ่อมในตลาดมีสองแบบ และช่องว่างปรากฏทันทีในอินพุตชนิดเฉพาะ

สำนักแทนที่ด้วย regex ใช้ค้นหาและแทนที่แบบทั่วโลกกับรูปแบบที่พัง ดูอินพุตนี้:

{"url": "http://example.com", 'note': 'fine'}

regex ที่เปลี่ยนเครื่องหมายคำพูดเดี่ยวเป็นคู่จะเคี้ยวเนื้อหาข้างใน URL ด้วย, regex ล้างคอมเมนต์ที่ลบทุก // จะตัด http:// ขาดกลาง ข้างในสตริงกับข้างนอกโครงสร้าง ตัวอักษรหน้าตาเหมือนกัน — regex แยกไม่ออก

สำนักเครื่องสถานะทีละอักขระ ติดตามสถานะการ parse: อยู่ในสตริงเครื่องหมายคำพูดคู่, เดี่ยว, อยู่ในคอมเมนต์บรรทัด, คอมเมนต์บล็อก, หรือกำลังรอค่า เห็น ' มันถามก่อน "ตอนนี้อยู่ในสตริงหรือเปล่า?" แล้วจึงตัดสินใจว่าจะเปลี่ยนเครื่องหมายคำพูดหรือข้าม http://example.com อยู่ในสตริงเครื่องหมายคำพูดคู่ ดังนั้นเครื่องสถานะรู้ว่า // ตรงนั้นเป็นข้อมูล ไม่ใช่คอมเมนต์ จึงเก็บไว้เหมือนเดิม jsonrepair และ json-healer อยู่ในสำนักนี้ และคำสวดของชุมชนที่ว่า "เครื่องมือซ่อมไม่ใช่ค้นหาและแทนที่" หมายถึงเรื่องนี้เป็นหลัก

ลำดับเต็มของไปป์ไลน์ซ่อม (ตามที่การใช้งาน devkits เปิดเผย) ก็น่าดู: ลอก fence → ทำเครื่องหมายคำพูดโค้งให้เป็นมาตรฐาน → สกัดบล็อกสมดุลแรก → เอาคอมเมนต์ออก → ห่อคีย์เปล่าด้วยเครื่องหมายคำพูด → เอาจุลภาคท้ายออก → แปลง literal → สุดท้าย serial ใหม่ด้วย JSON.stringify การ serial ใหม่ขั้นสุดท้ายนี่แหละคือก้าวสำคัญ: ไม่ว่าขั้นก่อนหน้าทำอะไร เอาต์พุตถูกสร้างใหม่จากผลการ parse ดังนั้น parser เข้มงวดใด ๆ ปลายน้ำก็กลืนได้

ห้า: ต่อเข้าโค้ด — ห่วงโซ่ parse ตามลำดับ

เมื่อต่อการซ่อมเข้าโค้ด ลำดับสำคัญกว่าการเลือกไลบรารี ตามรูปแบบที่ json2toon และ aijsonmedic เผยแพร่ ลำดับควรเป็น: ตรวจการตัดขาด → สกัดช่วง JSON → parse เข้มงวด → ซ่อมเป็นตัวสำรอง → ตรวจสอบด้วย schema

import { jsonrepair } from "jsonrepair";

export function parseModelJson(text, stopReason) {
  if (stopReason === "max_tokens") {
    // เอาต์พุตที่ถูกตัดถ้าซ่อมก็ยังขาดข้อมูล — ลองใหม่แทน
    throw new Error("Truncated output: retry with a higher max_tokens");
  }
  // สกัดช่วง JSON: LLM ชอบคุยเก่งทั้งหน้าและหลัง
  const start = text.search(/[[{]/);
  const end = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
  const candidate = start >= 0 && end > start ? text.slice(start, end + 1) : text;
  try {
    return JSON.parse(candidate);   // เส้นทางเร็วสำหรับอินพุตที่ถูกต้อง
  } catch {
    return JSON.parse(jsonrepair(candidate));  // ซ่อมเป็นตัวสำรอง
  }
}

ฝั่ง Python แพ็กเกจ json-repair (กว่า 4,700 ดาว) มี loads() ที่คืนออบเจ็กต์โดยตรง:

from json_repair import repair_json
import json

broken = "{name: 'Ada', tags: ['x',], active: True}"
data = json.loads(repair_json(broken))
# {'name': 'Ada', 'tags': ['x'], 'active': True}

รายละเอียดทางวิศวกรรมอีกสองข้อ:

  • จัดสแตกให้ตรงกัน ถ้าทั้ง frontend และ backend ต้องซ่อม เลือกการใช้งานที่มีความหมายร่วมกัน — Python json-repair กับพอร์ต TypeScript @yarmu/json-repair, หรือ jsonmend ที่เวอร์ชัน Python และ JS ผ่านคลังความสม่ำเสมอ 485 เคสเดียวกัน ไม่อย่างนั้นเอาต์พุตชุดเดียวจะซ่อมเป็น A ฝั่งไคลเอนต์และ B ฝั่งเซิร์ฟเวอร์ การดีบักกลายเป็นฝันร้าย
  • เปิดล็อกการซ่อม @yarmu/json-repair กับ logging: true คืนอาร์เรย์ของทุกการดำเนินการซ่อม อัตราการซ่อมพุ่งขึ้นฉับพลันมักแปลว่าพรอมป์หรือเวอร์ชันโมเดลเปลี่ยนไป — สัญญาณที่มาก่อนรายงานข้อผิดพลาดใด ๆ

มีอีกหนึ่งก้าวหลังการซ่อมที่ต่อรองไม่ได้: การตรวจสอบด้วย schema ถูกต้องตามไวยากรณ์ไม่ได้แปลว่าใช้ได้ ฟิลด์ขาด ประเภทผิด คีย์เกินมา — schema จับได้หมด แนวคิดการทดสอบสัญญาใช้ได้ตรงนี้เลย ดูคู่มือการทดสอบสัญญา JSON Schema ของเรา

หก: เช็กลิสต์การป้องกัน — การซ่อมที่ถูกที่สุดคืออันที่ไม่ต้องซ่อม

การซ่อมคือตัวสำรอง ชัยชน์ที่แท้จริงคือให้เกิด JSON พังน้อยลงตั้งแต่ต้นทาง เรียงตามลำดับความสำคัญ:

  1. Structured Outputs (โหมด json_schema) การถอดรหัสถูกบังคับด้วย schema จุลภาคท้ายจึงสร้างขึ้นไม่ได้เลย โหมด strict ของ OpenAI ล้มเหลวประมาณ 0.1% — แลกกับข้อกำหนดเข้มอย่าง additionalProperties: false
  2. โหมด JSON (json_object) รับประกันแค่ไวยากรณ์ถูกต้อง — ไม่รวมรูปทรง — และการตัดขาดเพราะเพดานโทเค็นยังเกิดอยู่
  3. คำสั่งที่ชัดเจน ปลายทางที่ไม่มีโหมด JSON การเขียนว่า "ห้าม fence ห้ามคอมเมนต์ ห้ามจุลภาคท้าย ให้แค่ออบเจ็กต์" ลดอัตราข้อผิดพลาดลง 70–80%
  4. ลด temperature เพิ่มเพดานโทเค็น อย่างแรกลดการเลื่อนไปเป็นร้อยแก้ว อย่างหลังลดการตัดขาด
  5. ลองใหม่โดยแนบข้อผิดพลาด เมื่อการตรวจสอบล้มเหลว เอาเอาต์พุตที่พักบวกกับ "พาธ JSON + ข้อความผิดพลาด" ใส่คืนบทสนทนาแล้วขอใหม่ โมเดลมักแก้ตัวเองได้เมื่อได้ข้อผิดพลาดที่แม่นยำ
  6. ล็อกเวอร์ชันไลบรารีซ่อมในไฟล์ล็อก พฤติกรรมกรณีเส้นขอบของเครื่องมือซ่อมเปลี่ยนได้ระหว่างเวอร์ชัน การอัปเดตอัตโนมัติโดยไม่รีวิวเท่ากับเปลี่ยนกลไกการเดาของไปป์ไลน์โดยไม่มีใครรู้ — อัปเดตได้ แต่ให้เป็นการตัดสินใจที่มีบันทึกและมีชุดทดสอบรองรับ

ในทางปฏิบัติการซ้อนกันสามชั้น "structured outputs + ซ่อมเป็นตัวสำรอง + ตรวจสอบ schema" ครอบคลุมแทบทุกสถานการณ์

เจ็ด: การแบ่งงาน — การแปลงภาษาถิ่นไม่ใช่การซ่อม

ในกล่องเครื่องมือของเว็บนี้มีสองจุดหมาย ครอบคลุมช่วงต่างกันของไปป์ไลน์นี้:

  • ปัญหาพวกภาษาถิ่น (คอมเมนต์ เครื่องหมายคำพูดเดี่ยว จุลภาคท้าย) ไปตรงที่ ตัวแปลง JSON5 การแปลงกลับไปมาระหว่าง JSON5 ↔ JSON มาตรฐานครอบคลุมพอดีสามชนิดนี้ ด้วยความหมายที่ชัดเจน ไม่เดา ถ้าอินพุตทั้งหมดเป็นไฟล์ JSONC/JSON5 การแปลงจะคาดเดาได้กว่าการซ่อม เรื่องการเลือกของภาษาถิ่นเอง ดูคู่มือ JSON5 และ JSONC
  • หลังซ่อมแล้ว ส่งผลผ่าน เครื่องมือ parse JSON เพื่อตรวจสอบและจัดรูป — ข้อผิดพลาดระบุถึงบรรทัดและคอลัมน์ ยืนยันว่า parser เข้มงวดยอมรับเอาต์พุตจริง ๆ
  • ปัญหาระดับไลบรารี (literal Python การเติมที่ถูกตัด ห่อ JSONP markdown fence) ยังต้องพึ่ง jsonrepair / json-repair ฝั่งโค้ด — การซ่อมคลิกเดียวที่เทียบเท่าในเบราว์เซอร์ยังไม่มี เพราะการซ่อมพวกนี้ต้องอนุมานเจตนา และไลบรารีในเครื่องเป็นที่ที่ปลอดภัยกว่าสำหรับมันกว่าเครื่องมือแปลงสากล

ถ้าที่มือถือคือข้อความผิดพลาด ไม่ใช่ข้อมูลที่พัง เริ่มจากคู่มือแก้ข้อผิดพลาดการ parse JSON เพื่อแปลข้อความเป็นพิกัด แล้วจึงตัดสินใจ: แก้มือหรือซ่อมด้วยเครื่องมือ

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

แปด: กับดักที่พบบ่อยเมื่อซ่อมด้วยมือ

ก่อนพึ่งเครื่องมือซ่อมอัตโนมัติ นักพัฒนาจำนวนมากยังเลือกแก้ด้วยมือ ซึ่งไม่ผิดตัวใด — แต่มีกับดักที่กลายเป็นตั๋วบัตรเข้าโหมดดีบักกลางดึกซ้ำแล้วซ้ำเล่า:

  1. ค้นหาและแทนที่แบบทั่วโลกในโปรแกรมแก้ไขข้อความ การแทนที่ ' ทั้งหมดด้วย " หรือลบคอมเมนต์ทั้งหมดด้วย regex ในโปรแกรมแก้ไข เหมือนกับสำนัก regex ที่กล่าวถึงข้างต้นทุกประการ — และรับผิดชอบข้อผิดพลาดรูปแบบเดียวกันด้วย อย่างน้อยควรตรวจผลลัพธ์ด้วย parser เข้มงวดหนึ่งรอบก่อนบันทึกไฟล์
  2. ลืมตัวหนีตัวอักษรหลังแก้เครื่องหมายคำพูด เมื่อเปลี่ยนเครื่องหมายคำพูดเดี่ยวเป็นคู่ด้วยมือ ข้อความภายในที่มีเครื่องหมายคำพูดคู่ฝังอยู่กลายเป็นสตริงที่ปิดก่อนเวลาอันควร รูปแบบที่ถูกต้องคือ \" — การแก้ด้วยมือพลาดขั้นตอนนี้ง่ายที่สุดเมื่อสตริงมีเนื้อหายาว
  3. ถือว่าข้อผิดพลาดตัวแรกคือต้นเหตุทั้งหมด parser หยุดที่ข้อผิดพลาดแรกที่เจอ แต่ไฟล์คอนฟิกที่แก้ด้วยมือมักสะสมข้อผิดพลาดหลายจุด แก้จุดหนึ่งแล้ว parse ต่อไปเจอจุดถัดไปเป็นเรื่องปกติ วางใจว่าข้อผิดพลาดตัวสุดท้ายจะมาทีละตัว จึงเป็นเหตุผลที่ห่วงโซ่ parse อัตโนมัติชนะการแก้ด้วยมือในงานประจำ
  4. ซ่อมแล้วแต่ไม่เก็บต้นฉบับไว้เทียบ เมื่อการซ่อมเปลี่ยนพฤติกรรมของข้อมูล (เช่น 007 กลายเป็นสตริง) ถ้าไม่มีต้นฉบับเทียบ จะยากมากที่จะรู้ทีหลังว่าค่าใดถูกเครื่องมือปรับเปลี่ยน เก็บอินพุตดิบไว้ในบันทึกหรือในที่เก็บข้อมูลชั่วคราวเสมอ

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

เก้า: ติดตามหลังเสียบเข้าระบบ — ตัวเลขที่ควรดู

การต่อเครื่องมือซ่อมเข้า production ไม่ใช่จุดจบของเรื่อง ต้องมีตัวชี้วัดคอยเฝ้าดู ไม่เช่นนั้นจะไม่มีใครรู้เลยว่าคุณภาพของเอาต์พุตโมเดลเปลี่ยนไปในทิศทางใด:

  1. อัตราการเข้าเส้นทางซ่อม สัดส่วนของคำขอที่ JSON.parse ล้มเหลวแล้วต้องพึ่ง jsonrepair ถ้าตัวเลขนี้พุ่งจาก 5% เป็น 30% ภายในคืนเดียว แปลว่าพรอมป์ถูกแก้ โมเดลถูกสลับเวอร์ชัน หรือข้อจำกัดโทเค็นถูกลดลง — รู้ก่อนผู้ใช้จะรายงาน
  2. อัตราการล้มเหลวหลังตรวจ schema เอาต์พุตที่ซ่อมแล้วแต่ตรวจ schema ไม่ผ่าน เป็นตัวชี้วัดที่ตรงที่สุดว่า "การซ่อมได้ผลจริงแค่ไหน" ถ้าตัวเลขนี้สูง แปลว่าปัญหาอยู่ที่โครงสร้างไม่ใช่วรรคตอน และควรย้ายแรงงานไปเขียนพรอมป์และ schema ให้เข้มขึ้น
  3. การกระจายเหตุผลการตัดขาด นับ stopReason ทุกครั้ง ถ้า max_tokens กินสัดส่วนมากขึ้น เพิ่มเพดานโทเค็นก่อนที่จะเพิ่มความซับซ้อนของลอจิกการซ่อมเติมให้สมบูรณ์
  4. เวลาที่เสียไปกับการซ่อม การซ่อมไม่ฟรี ทั้ง CPU ทั้งเวลาแฝง ถ้าอัตราการเข้าเส้นทางซ่อมสูงถาวร ลงทุนกับ structured outputs ถูกกว่าการเลี้ยงเครื่องมือซ่อมตลอดชีวิตของระบบ

หลักการเดียวกับการทำงานวิศวกรรมชิ้นใหญ่ทุกชิ้น: ตัวเลขที่มองไม่เห็น ปรับปรุงไม่ได้ — และการซ่อมที่เฝ้าดูไม่ได้ ก็เท่ากับเป็นท่อระบายข้อผิดพลาดเงียบ ๆ ที่โตขึ้นทุกวัน

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

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

การซ่อม JSON ทำให้ข้อมูลผมเสียหายไหม?

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

การซ่อมกับการตรวจสอบเกี่ยวข้องกันอย่างไร?

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

LLM ห่อเอาต์พุตด้วย fence ```json ตลอด — ทำอย่างไร?

ระยะสั้น: สกัดออกมา เอาข้อความจาก { หรือ [ ตัวแรกถึง } หรือ ] ตัวสุดท้ายแล้ว parse เครื่องมือซ่อมที่ลอก fence ได้ก็กลืนทั้งข้อความได้ ระยะยาว: ใช้ structured outputs หรือคำสั่งชัดว่า "ห้าม markdown fence" เพื่อไม่ให้ fence เกิดขึ้นเลย

jsonrepair หรือ json-repair เลือกตัวไหน?

JavaScript ใช้แพ็กเกจ npm jsonrepair (รองรับ transform แบบสตรีม), Python ใช้ json-repair จาก PyPI ถ้าสองฝั่งต้องซ่อม เลือกคู่ที่ความหมายตรงกัน — เช่น json-repair กับพอร์ต TS — เพื่อให้อินพุตเดียวกันซ่อมได้ผลเหมือนกันทั้งสองฝั่ง

เครื่องมือซ่อมจัดการภาษาไทยและเครื่องหมายคำพูดโค้งได้ไหม?

ได้ เครื่องหมายคำพูดที่มาจากคีย์บอร์ดไทย (“ ”), เว้นวรรคเต็มความกว้าง และ BOM หัวไฟล์ อยู่ในรายการซ่อมมาตรฐานทั้งหมด เครื่องหมายคำพูดโค้งถูกทำให้เป็นเครื่องหมายตรง ส่งผลผ่านตัวตรวจสอบหนึ่งรอบก็จบ

ควรซ่อมทุกคำขอเลยไหม หรือซ่อมเฉพาะเมื่อ parse ล้มเหลว?

ซ่อมเฉพาะเมื่อ parse ล้มเหลวเสมอ — เส้นทางเร็วของการ parse เข้มงวดต้องมาก่อนทุกครั้ง การเรียกเครื่องมือซ่อมกับ JSON ที่ถูกต้องอยู่แล้วเป็นการเปลือง CPU โดยไม่จำเป็น และในกรณีเส้นขอบที่หาได้ยาก เพิ่มความเสี่ยงให้อินพุตที่ดีถูกแตะโดยไม่ตั้งใจ ห่วงโซ่ try/catch ในโค้ดตัวอย่างข้างบนจัดเรื่องนี้ให้อยู่แล้ว

ทำไมเครื่องมือซ่อมออนไลน์บางตัวให้ผลต่างกันกับไลบรารี?

เพราะพฤติกรรมของกรณีเส้นขอบ (ตัวเลขศูนย์นำหน้า, NaN, คีย์ซ้ำ) ขึ้นกับการตัดสินใจของผู้ใช้งานแต่ละรายไม่มีมาตรฐานกลาง ก่อนเสียบไลบรารีเข้าไปป์ไลน์จริง ทดสอบกับอินพุตขยะที่ระบบของคุณเจอจริงหลายตัวอย่าง แล้วล็อกเวอร์ชันของไลบรารี — การอัปเดตเวอร์ชันใหญ่ของไลบรารีซ่อมเป็นอีกจุดที่พฤติกรรมเปลี่ยนได้โดยไม่แจ้งล่วงหน้า

เอาต์พุตที่ตัดขาดควรเติมให้สมบูรณ์หรือขอโมเดลใหม่?

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

แหล่งอ้างอิง

เครื่องมือที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง

JSON5 และ JSONC: JSON ที่มี Comment

ทั้งสองภาษาถิ่นมีอยู่เพราะ config ที่มนุษย์เขียนต้องมี comment และ trailing comma แต่ไวยากรณ์และการเข้าถึงระบบนิเวศต่างกัน เลือกผิด toolchain ก็ติดขัด

ผู้เริ่มต้นอ่านประมาณ 10 นาทีอัปเดต 2026-10-30

วิธีแก้ JSON parse error: ตรวจ Unexpected token ทีละขั้น

แปลง error ของ JSON.parse ให้เป็นบรรทัดและตัวอักษร แล้วตัดสาเหตุหกประการออกไป: เครื่องหมายจุลภาคท้ายรายการ เครื่องหมายคำพูดเดี่ยว คอมเมนต์ อักขระควบคุม BOM และการตัดทอนข้อมูล

ผู้เริ่มต้นอ่านประมาณ 12 นาทีอัปเดต 2026-11-01

การทดสอบสัญญา JSON Schema: เชื่อมกฎการตรวจสอบเข้ากับ CI

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

ระดับกลางอ่านประมาณ 8 นาทีอัปเดต 2026-11-05