แยกวิเคราะห์ JSON ที่ยังมาไม่ครบ: ดูตัวอย่างแบบสตรีมและซ่อมแบบเพิ่มทีละส่วน
สรุปสำคัญ: โมเดล LLM ส่ง JSON ออกมาทีละ token และ API ส่งคำตอบขนาดใหญ่มาเป็นชิ้น ๆ แต่ JSON.parse กลับไม่ยอมเริ่มทำงานจนกว่าเอกสารทั้งหมดจะมาถึง บทความนี้แยกแนวทางพัฒนาออกเป็นสามแบบ — ซ่อมทั้งฉบับ เพิ่มทีละส่วนแบบแท้จริง และแยกวิเคราะห์บางส่วน — อธิบายว่า mask Allow ทำให้ตัวอย่างที่ดูอยู่นิ่งได้อย่างไร พร้อมผลวัด pipeline และโค้ดที่พร้อมใช้จริง

JSON.parseสัญญาว่า «จะเริ่มเมื่อเอกสารมาถึงครบทั้งฉบับ» ขณะที่สตรีมสัญญาว่า «จะส่งข้อมูลให้ทีละชิ้น» ความขัดแย้งไม่ได้อยู่ที่ความเร็ว แต่อยู่ที่ความหมายของความสมบูรณ์: เอกสารที่ยังเขียนไม่จบยังไม่มี «ผลลัพธ์การแยกวิเคราะห์ที่ถูกต้อง» จะเอามาเทียบได้เลย
อาการ: สามสถานการณ์ที่รอเอกสารเต็มไม่ไหว
สถานการณ์แรกคือแอปพลิเคชัน LLM โมเดลส่ง JSON ออกมาทีละ token; output ที่มีโครงสร้างขนาด 8KB อาจใช้เวลาหลายสิบวินาทีกว่าจะมาครบ ระหว่างนั้นผู้ใช้จ้องช่องว่างเปล่า — ทั้งที่ field แรก ๆ แสดงได้ตั้งแต่วินาทีแรกแล้ว สถานการณ์ที่สองคือ gateway และ proxy: upstream ดัน response ขนาดหลายสิบ MB มาเป็น HTTP chunk ถ้า proxy อยากกรอง field ก่อนส่งต่อแล้วบัฟเฟอร์ทั้งหมดด้วย res.json() ความสูงสุดของหน่วยความจำจะถูกคูณขึ้นหลายเท่า สถานการณ์ที่สามคือ message queue และ log pipeline: ระเบียน NDJSON มาถึงต่อกันเป็นสายเดียว consumer ไม่อยากสะสมเป็นชุด
จุดร่วมชัดเจน: ข้อมูลมาถึงทีละส่วน แต่ตัวแยกวิเคราะห์มาตรฐานรับเฉพาะเอกสารที่สมบูรณ์ JSON.parse โยน Unexpected end of JSON input ตั้งแต่ชิ้นแรก ยังโยน error เดิมที่ชิ้นที่ 65 และคืนผลลัพธ์เฉพาะชิ้นสุดท้ายเท่านั้น การรอไม่ใช่ทางเลือกเดียว — แต่ก่อนอื่นคุณต้องตอบให้ได้ว่า «แยกวิเคราะห์» เอกสารที่ยังเขียนไม่จบ หมายความว่าอะไร
ความหมายของการแยกวิเคราะห์ตาม prefix: ทุกชิ้นใช้ได้หรือไม่
ยกอาร์เรย์คำสั่งซื้อขนาด 7847 ไบต์ ตัดเป็นชิ้นละ 120 อักขระเพื่อจำลองการมาถึงแบบสตรีม (Node v22.13.1, jsonrepair 3.15.0, partial-json 0.1.7) แล้วส่งทุก prefix ผ่านตัวแยกวิเคราะห์สามตัว:
| วิธีแยกวิเคราะห์ | สำเร็จกี่ครั้งจาก 66 prefix | เวลาสะสม | ความหมาย |
|---|---|---|---|
JSON.parse |
1 (เฉพาะชิ้นสุดท้าย) | 2.1 ms | ได้ทั้งหมดหรือไม่ได้เลย |
partial-json (Allow.ALL) |
66 (ตั้งแต่ชิ้นแรก) | 14.3 ms | คืน «ที่รู้มาถึงตอนนี้» เสมอ |
jsonrepair รันซ่อมทั้งฉบับซ้ำทุก prefix |
66 | 23.8 ms | แยกได้หลังเติมวงเล็บ แต่คำนวณใหม่ตั้งแต่ต้นทุกครั้ง |
ข้อสรุปสำคัญมีสองข้อ หนึ่ง: ความล้มเหลวของ JSON.parse ไม่แถมข้อมูลอะไรมาเลย — ตำแหน่ง error ที่รายงานคือท้ายสุดเสมอ คุณไม่รู้ทั้งยังขาดอีกเท่าไร และส่วนที่รับมาแล้วสอดคล้องกันเองไหม สอง: การรันซ่อมทั้งฉบับซ้ำในทุก prefix ทำได้แต่ไม่คุ้ม: ความยาวข้อความเฉลี่ยต่อการเรียกโตแบบเชิงเส้น ต้นทุนสะสมโตแบบยกกำลังสอง O(n²) 23.8 ms ดูไร้อันตราย แต่พอข้อความไปถึงระดับ megabyte ตัวคูณเดียวกันจะกลายเป็นวินาที CPU ที่เสียเปล่า
และต้องระวังอีกข้อ: «แยกได้ตาม prefix» ไม่เท่ากับ «ข้อมูลครบ» ตัวเลขตัวสุดท้ายของ prefix ที่เติมวงเล็บแล้วอาจถูกชิ้นถัดไปเขียนต่อ สตริงตัวสุดท้ายอาจถูกตัดกลางลำดับ escape — นี่คือรากเหง้าของปัญหาความนิ่งทั้งหมดของการดูตัวอย่างแบบสตรีม
สามแนวทางพัฒนาแบ่งงานกันอย่างไร
ไลบรารีฝั่งสตรีมแบ่งเป็นสามท่าที และเลือกท่าทีผิดเจ็บกว่าเลือกไลบรารีผิด:
| ไลบรารี | ท่าที | เหมาะกับ | ไม่เหมาะกับ |
|---|---|---|---|
jsonrepair (3.15.0) |
ซ่อมทั้งฉบับ + Transform stream | ได้รับ «เอกสารที่สักวันจะมาครบ» และต้องการผลลัพธ์ไม่สูญเสีย | แค่ดูตัวอย่าง (output เป็นข้อความซ่อมแล้วทั้งก้อน ไม่ใช่ object ของข้อมูล) |
partial-json (0.1.7) |
แยกวิเคราะห์บางส่วน ยอมให้ทิ้งส่วนท้ายที่ยังไม่จบ | ดูตัวอย่าง UI: ทุก prefix มี object ใช้งานได้ทันที | บันทึกลงฐานข้อมูล (ตัวอย่างอาจขาด field ตัวเลขไม่นิ่ง) |
jsonmend (0.1.3) |
เพิ่มทีละส่วนแบบแท้จริง เปิด corpus ความสอดคล้องแบบสาธารณะ | pipeline แบบ «รับเข้าส่วนหนึ่ง ออกมาเป็นเวอร์ชัน» ไม่ไล่อ่านส่วนก่อนหน้าซ้ำ | เอกสารที่จบแล้ว (แยกทั้งฉบับเร็วกว่า) |
สามตัวนี้ไม่ได้แข่งกัน jsonrepair เปิด jsonrepairTransform ผ่าน subpath ./stream เป็น Transform stream มาตรฐาน: ดันชิ้นเข้าทางซ้าย ทางขวาออกมาเป็นบล็อกข้อความ JSON ที่ซ่อมแล้ว และ รับประกันว่าต่อกันแล้วเท่ากับผลแยกวิเคราะห์ทั้งฉบับครั้งเดียว — เงื่อนไข decode(encode(x)) === x มันรักษาได้ partial-json ถือเส้นอื่น: ทุก prefix คืน object ทันที โดยแลกกับการสละคำสัญญา «ผลลัพธ์สุดท้ายจะไม่เปลี่ยน» ส่วน jsonmend รั้งเส้นที่สามด้วย corpus ความสอดคล้องแบบสาธารณะ: เพิ่มทีละส่วนแบบแท้จริง ความหมายเทียบกันได้ ทั้งสองฝั่งพัฒนาใช้ฐาน regression เดียวกัน
mask Allow: field ไหนกล้าแสดงในตัวอย่าง
แก่นของ partial-json ไม่ใช่ «แยกได้ทุก input ที่พังแบบใดก็ได้» แต่คือ ฝั่งผู้เรียกประกาศเองว่ายอมรับความไม่ครบระดับไหน mask ประกอบกันเป็นบิตตามชนิดของ JSON (STR, NUM, ARR, OBJ…) เอาชนิดไหนออก ค่าที่ยังไม่จบของชนิดนั้นจะไม่เข้าตัวอย่าง:
import { parse, Allow } from 'partial-json';
parse('{"price": 12', Allow.ALL);
// → { price: 12 } เลข 12 คือ «อ่านมาถึงตรงนี้»
parse('{"price": 1234.5', Allow.ALL);
// → { price: 1234.5 } field เดิมเปลี่ยนไปแล้ว: ตัวอย่างไม่นิ่ง
parse('{"price": 12', Allow.ALL & ~Allow.NUM);
// → {} ตัดบิต NUM ออก เลขที่ยังไม่จบจะไม่แสดง
นี่คือข้อค้นพบที่มีค่าทางวิศวกรรมที่สุดจากการวัด: ตัวเลขอย่างราคาและตัวนับที่ชิ้นถัดไปอาจเขียนต่อ เปลี่ยนบน UI ทุกเฟรม ขณะที่ Allow.ALL & ~Allow.NUM สั่งให้มันเงียบรอจนเขียนจบค่อยโผล่ สตริงก็เช่นเดียวกัน — สตริงที่ถูกตัดกลางลำดับ escape Unicode partial-json 0.1.7 ทิ้งอย่างปลอดภัยแทนการเดา ความนิ่งของตัวอย่างไม่ใช่ของขวัญจากตัวแยกวิเคราะห์ ผู้เรียกต้องซื้อมันด้วย mask
ต้นทุนการพัฒนาซ่อมแบบสตรีม: look-back buffer และการคัดลอกแบบยกกำลังสอง
pipeline แบบสตรีมไม่ใช่เอา API ทั้งฉบับมาห่อด้วยลูป for บนชุดตัวอย่าง 66 ชิ้นเดียวกัน pipeline ที่ใช้ jsonrepairTransform ใช้เวลารวม 6.7ms ขณะที่รันซ่อมทั้งฉบับซ้ำทุก prefix สะสม 23.8ms — ช่องว่าง 3.5 เท่ามาจากชั้นการพัฒนา: ตัวสตรีมเหลียวกลับเฉพาะในหน้าต่างที่จำเป็น output เขียนต่อด้วยบัฟเฟอร์แบบเพิ่มทีละส่วน ไม่คัดลอกส่วนก่อนหน้าซ้ำไปมา
การพอร์ตแกนสตรีมของ jsonrepair ไปยัง HarmonyOS ArkTS (ประสบการณ์ปรับตัวไลบรารีบุคคลที่สามของ openHarmony) เผยต้นทุนเจาะจงสามข้อ: เส้นทาง streaming ฝั่งต้นทางต้องสะสม «look-back buffer» เอกสารเล็กจึงต้องรอ flush — ผู้เขียนจึงเขียน IncrementalRepairer แยกไว้สำหรับข้อความสั้น; เส้นทาง regular ฝั่งต้นทางคัดลอก output ทั้งก้อนซ้ำหลายรอบ มีลักษณะยกกำลังสอง และตอนพอร์ต OutputBuilder กำจัดมันทิ้ง; และยังมีกับดักอักขระขอบ — เงื่อนไข text[i] === undefined ที่ใช้ทดสอบ «อ่านถึงท้ายแล้ว» เมื่อเปลี่ยนเป็น charAt จะถูกหลอก เพราะ ''.includes('') เป็น true เสมอ การล้นขอบจึงต้องกันด้วยสตริงว่างไว้ก่อน รายละเอียดเหล่านี้อธิบายว่าทำไม «ซ่อมแบบสตรีม» จึงสมควรมีช่องหมวดหมู่เป็นของตัวเอง: ความซับซ้อนทางวิศวกรรมของมันกับการซ่อมครั้งเดียวไม่อยู่ระดับเดียวกัน
ควรจดขอบเขตที่รู้แล้วด้วย: issue #214 ของ jsonrepair รายงานว่าการซ่อมแบบสตรีมปฏิเสธ prefix ที่ถูกต้องซึ่งขาด comma หน้าค่าที่มี slash — ในโหมดสตรีม ในระดับ lexical แยกยากว่า «อักขระถัดไปยังมาไม่ถึง» กับ «input ไม่ถูกต้อง» ต่างกันอย่างไร หน้าต่าง look-back ก็คือราคาที่จ่ายเพื่อความกำกวมข้อนี้
ใช้งานจริงอย่างไร: ดูตัวอย่างกับบันทึกแยกเส้นทางกัน
ประกอบความหมายข้างต้นเป็น pipeline เดียว หลักการกะไว้ในประโยคเดียว: ดูตัวอย่างใช้การแยกบางส่วน บันทึกใช้การแยกแบบเข้มงวด
import { jsonrepairTransform } from 'jsonrepair/stream';
import { parse as partialParse, Allow } from 'partial-json';
// เส้นทาง 1: pipeline ไม่สูญเสีย เข้า: ชิ้นส่วน ออก: ข้อความ JSON ที่ซ่อมแล้ว ปิดท้ายด้วยการตรวจแบบเข้มงวด
const tr = jsonrepairTransform();
tr.pipe(finalSink); // finalSink ต่อไปทำ JSON.parse + ตรวจสอบของธุรกิจ
chunkStream.pipe(tr);
// เส้นทาง 2: pipeline ดูตัวอย่าง ทุก prefix ให้หนึ่งเฟรม UI เลขและสตริงที่ยังไม่จบถูก mask กักไว้
function onChunk(buffer) {
const preview = partialParse(buffer, Allow.ALL & ~Allow.NUM & ~Allow.STR);
render(preview); // วาดเฉพาะ field ที่นิ่ง field ที่เปลี่ยนเร็วให้รอไป
}
สัญญาของสองเส้นทางต่างกันและแทนกันไม่ได้: เฟรมดูตัวอย่างขาด field ได้ เฟรมบันทึกขาดไม่ได้ เฟรมบันทึกต้องรอ stream จบและผ่าน JSON.parse เต็มรูปพร้อมตรวจสอบของธุรกิจ ส่วนเฟรมดูตัวอย่างไม่เคยบันทึกลงไหนเลย ถ้าต้นทางเป็น output ของ LLM ก่อนบันทึกต้องประเมินตาม stop_reason ว่าถูกตัดหรือไม่ — ขั้นตอน «ดู stop_reason ก่อนแล้วค่อยคุยเรื่องซ่อม» มีอยู่แล้วในบทความ ซ่อม JSON ที่ถูกตัดจาก LLM ที่นี่ไม่พูดซ้ำ
เมื่อไรไม่ควรทำสตรีม
สามเงื่อนไขยับยั้ง โดนข้อใดข้อหนึ่งก็ใช้แยกทั้งฉบับอย่างตรงไปตรงมา: ไฟล์เล็ก — JSON.parse ธรรมดาอ่านถึง ~22MB ในครั้งเดียวมักไม่ถึงวินาที สตรีมเพิ่มโค้ดให้เฉย ๆ; แค่สถิติครั้งเดียว — การรวมข้อมูลใช้ jq --stream หรือ NDJSON ทีละบรรทัดสะดวกกว่า ดู คู่มือปฏิบัติ JSONL; ผู้รับปลายทางไม่รับข้อมูลบางส่วน — เช่นยอดรวมเงิน ค่ากลางที่คูณผิดสักตัวจากตัวอย่างคือขาดทุนจริง ตอนนั้นการดูตัวอย่างสตรีมเหลือค่าแค่ «แถบความคืบหน้า»
สิ่งที่การแยกวิเคราะห์แบบสตรีมแก้ให้คือ «รอไม่ไหว» เสมอ ไม่ใช่ «เร็วขึ้น» ด้วยปริมาณข้อความเท่ากัน CPU รวมของการแยกทั้งฉบับน้อยกว่าทุกทางเลือกสตรีมเสมอ สิ่งที่คุณแลกได้คือเวลาจนถึงไบต์แรกที่ใช้งานได้ และระดับหน่วยความจำที่คงที่ คิดเรื่องแลกเปลี่ยนนี้ให้ชัด การเลือกเทคโนโลยีก็จะไม่สั่นคลอนอีก
ปรับขนาดชิ้นส่วนและเฝ้าระวังอย่างไรให้เสถียร
ขนาดชิ้นส่วนที่ป้อนเข้าสู่ตัวซ่อมมีผลต่อทั้งความเร็วและความล่าช้าของการแสดงผล ถ้าชิ้นเล็กเกินไป ต้นทุนต่อการเรียกใช้จะกินสัดส่วนมากเกินความจำเป็น เพราะทุกการเรียกต้องพกค่าใช้จ่ายคงที่ของการดูแลสถานะไปด้วย ถ้าชิ้นใหญ่เกินไป ประโยชน์ของการดูตัวอย่างแบบเรียลไทม์จะหายไป เพราะผู้ใช้รอครบก้อนใหญ่เหมือนเดิม จากการทดลองในบทความนี้ที่ตัดข้อมูลเป็นชิ้นละ 120 อักขระ ผลลัพธ์ยังอยู่ในระดับมิลลิวินาที แต่สำหรับระบบจริงที่ความล่าช้าของการแสดงผลสำคัญ มักคุ้มค่าที่จะรวมข้อมูลเล็ก ๆ ให้เป็นชิ้นประมาณหนึ่งถึงสี่กิโลไบต์ก่อนส่งเข้าไลบรารี และวัดเวลาจริงบนระบบของตัวเองทุกครั้ง
ด้านการเฝ้าระวัง ให้เก็บตัวชี้วัดอย่างน้อยสามตัวเมื่อระบบเริ่มทำงานจริง: จำนวนชิ้นส่วนที่ประมวลผลต่อวินาที ขนาดหน่วยความจำที่ใช้ในช่วงสูงสุด และอัตราความล้มเหลวของการตรวจสอบฉบับสมบูรณ์ตอนจบ อัตราความล้มเหลวที่พุ่งขึ้นผิดปกติมักบอกได้ทันทีว่ามีแหล่งข้อมูลต้นทางส่งข้อมูลที่ไม่ใช่ JSON มาปน หรือการเชื่อมต่อถูกตัดกลางคันบ่อยกว่าเดิม ตัวชี้วัดทั้งสามนี้ราคาถูกและจับได้ง่าย แต่ช่วยกันโรคที่พบบ่อยที่สุดของระบบสตรีมคือความเสถียรของปลายน้ำที่คุณมองไม่เห็น
เมื่อการเชื่อมต่อขาดกลางคัน จะกู้คืนอย่างไร
ความล้มเหลวที่พบมากที่สุดของระบบสตรีมไม่ใช่ข้อมูลเสียหาย แต่เป็นการเชื่อมต่อที่ถูกตัดกลางทาง วิธีจัดการที่ถูกต้องคือแยกให้ชัดระหว่างข้อมูลที่ประมวลผลเสร็จแล้วกับข้อมูลที่ค้างอยู่ในบัฟเฟอร์ ส่วนที่ประมวลผลเสร็จและได้รับการยืนยันแล้วมีสถานะเป็นถาวร ส่วนที่ยังค้างต้องทิ้งหรือเก็บไว้รอการเริ่มใหม่ อย่าพยายามหลอกตัวเองว่าข้อมูลครึ่งจานที่รับมาได้ครบถ้วน ให้ตอบกลับผู้เรียกด้วยสถานะล้มเหลวอย่างตรงไปตรงมา แล้วให้ฝั่งต้นทางส่งซ้ำตั้งแต่จุดที่ยืนยันครั้งล่าสุด ซึ่งต้องอาศัยการระบุตำแหน่งชัดเจนในข้อความขออีกครั้ง
ข้อผิดพลาดที่พบบ่อยรองลงมาคือการกู้คืนที่ทำให้ข้อมูลซ้ำซ้อน ถ้าฝั่งรับบันทึกข้อมูลลงระบบก่อนยืนยันความสำเร็จกับฝั่งต้นทาง การส่งซ้ำจะทำให้บรรทัดเดิมถูกเขียนสองครั้ง แนวทางแก้คือกำหนดรหัสเฉพาะตัวให้ทุกข้อความและทำให้การเขียนลงระบบสามารถทำซ้ำได้อย่างปลอดภัย โดยเขียนซ้ำกี่ครั้งก็ให้ผลลัพธ์เหมือนเขียนครั้งเดียว เทคนิคเหล่านี้ไม่ใช่เรื่องเฉพาะของ JSON แต่เมื่อรวมกับความหมายของเอกสารที่ไม่สมบูรณ์ที่อธิบายไว้ในบทความนี้ จะเห็นว่าการจัดการความล้มเหลวของระบบสตรีมต้องคิดตั้งแต่ก่อนเขียนโค้ดแรก
คำถามที่พบบ่อย
เอา object ตัวอย่างไปเก็บลงฐานข้อมูลได้เลยไหม?
ไม่ได้ ตัวอย่างคือภาพนิ่งของ «ที่รู้มาถึงตอนนี้»: เลขอาจถูกเขียนต่อ สตริงอาจถูกตัด field อาจขาดชั่วคราว ก่อนบันทึกต้องรอ stream จบ รัน JSON.parse แบบเข้มงวดเต็มฉบับหนึ่งรอบ แล้วผ่านการตรวจสอบของธุรกิจ ตัวอย่างเป็นของชั้น UI เท่านั้น
เลือก partial-json หรือ jsonrepair?
ขึ้นกับว่าคุณอยากได้ข้อความหรือ object ข้อความที่ซ่อมแล้วไม่สูญเสีย (ส่งต่อให้แยกอีกที) ใช้ jsonrepair — output สตรีมของมันรับประกันตรงกับการแยกทั้งฉบับ object ต่อ prefix โชว์ขึ้น UI ทันที ใช้ partial-json โดยตั้ง mask Allow ตามความไม่นิ่งที่คุณแบกไหว
การแยกวิเคราะห์แบบสตรีมลดเวลารวมลงไหม?
ไม่ CPU รวมของการแยกทั้งฉบับน้อยที่สุดเสมอ ทางเลือกสตรีมยังต้องจ่ายค่าดูแลสถานะเพิ่ม สตรีมแลกมาสามอย่าง: เวลาจนชิ้นแรกใช้ได้ หน่วยความจำที่ไม่โตตามความยาวทั้งฉบับ และความสามารถประมวลผลระหว่างรับ (ส่งต่อ กรอง แสดงผล)
สมาชิกอาร์เรย์มาถึงทีละตัว อยากจัดการทีละตัว ทำยังไง?
นั่นเป็นเส้นทางอีกทาง: stream-json กับ streamArray โยน {key, value} ตอนสมาชิกปิดสนิท และกับ for await เกิด backpressure ตามธรรมชาติ เหมาะกับการ import ก้อนใหญ่แบบ «แยกแล้วเขียน» ส่วนบทความนี้คุยเรื่องดูตัวอย่างในระดับทั้งฉบับ
ถ้าเอกสารมาแบบ NDJSON แยกทีละบรรทัด ต้องใช้เทคนิคนี้เลยไหม?
ไม่จำเป็นเลย รูปแบบ NDJSON แต่ละบรรทัดเป็นเอกสาร JSON ที่สมบูรณ์ในตัวเอง คุณเพียงแยกบรรทัดด้วย newline แล้ว JSON.parse ทีละบรรทัดก็พอ ไม่มีปัญหาเรื่องเอกสารที่ยังเขียนไม่จบเลย ปัญหาที่เหลือมีแค่เรื่องหนึ่งคือบรรทัดสุดท้ายอาจถูกเขียนค้างอยู่ครึ่งหนึ่ง ให้ตรวจว่าข้อมูลที่รับมาจบด้วย newline หรือเก็บส่วนท้ายที่ยังไม่สมบูรณ์ไว้รอข้อมูลชุดถัดไป รายละเอียดทั้งหมดของรูปแบบนี้อยู่ในบทความ คู่มือปฏิบัติไฟล์ JSONL
เอาไปใช้กับภาษาอื่นนอกจาก JavaScript ได้ไหม เช่น Python หรือ Go?
ได้ แต่ต้องเลือกเครื่องมือให้ตรง Python มีไลบรารี partial JSON parser หลายตัวที่ทำงานคล้าย partial-json ฝั่ง Node ส่วน jsonrepair มีเวอร์ชัน Python ที่พอร์ตมาแล้ว Go มี JSON stream decoder ใน standard library ที่รองรับการอ่านค่าต่อเนื่องจาก io.Reader ได้อยู่แล้ว หัวใจของเรื่องไม่ได้ผูกกับภาษาใดภาษาหนึ่ง แต่อยู่ที่ความหมายของการแยกวิเคราะห์บางส่วนที่อธิบายไว้ในบทความนี้ ไม่ว่าจะเขียนด้วยภาษาอะไร หลักการเดียวกันนี้คือ: ประกาศให้ชัดว่ายอมรับความไม่ครบถ้วนแบบไหน แยกเส้นทางดูตัวอย่างออกจากเส้นทางบันทึกข้อมูล และตรวจสอบเอกสารฉบับสมบูรณ์ก่อนนำไปใช้งานจริงเสมอ
แล้วถ้าต้องการทั้งดูตัวอย่างและเก็บประวัติทุกเวอร์ชันลง log ล่ะ?
กรณีนี้ยอมรับได้ถ้าจุดประสงค์คือการตรวจสอบย้อนหลัง (audit) ไม่ใช่การใช้งานข้อมูลโดยตรง บันทึกลง log ได้เพราะ log ไม่ได้ถูกนำไปคำนวณต่อ แค่เก็บไว้ดูภายหลังเท่านั้น แต่ควรระบุให้ชัดในบันทึกว่าเป็นสแนปชอตระหว่างทาง ใส่ลำดับเลขชิ้นส่วนและเวลาที่รับมา และแยกให้ออกจากระเบียนสุดท้ายที่ผ่านการตรวจสอบฉบับเต็มแล้ว อย่าปล่อยให้ระบบรายงานหรือระบบเรียกเก็บเงินไปอ่านข้อมูลจากชั้น log นี้เด็ดขาด เพราะค่าที่เขียนค้างอยู่จะทำให้ตัวเลขไม่ตรงกับความจริง