ตัวจัดรูปแบบ JSONL

วาง JSONL หรือ NDJSON ที่นี่ ระบบจะข้ามบรรทัดว่างโดยอัตโนมัติ และแต่ละบรรทัดข้อมูลต้องเป็นอ็อบเจ็กต์ JSON ที่สมบูรณ์หนึ่งรายการ

ผลลัพธ์ที่จัดรูปแบบแล้วจะแสดงที่นี่

แต่ละบรรทัดที่ไม่ว่างควรเป็นอ็อบเจ็กต์ JSON ที่สมบูรณ์หนึ่งรายการ

จำนวนบรรทัดทั้งหมด: 1บรรทัดที่ไม่ว่าง: 0บรรทัดที่ถูกต้อง: 0บรรทัดที่ไม่ถูกต้อง: 0
วาง JSONL เพื่อเริ่มจัดรูปแบบทันที

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

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

จัดรูปแบบ JSON

ซ่อมแซม JSON

บีบอัด JSON

JSON Stringify

ตัวตรวจสอบ JSON Schema

การจัดรูปแบบ JSONL คืออะไร?

JSONL (JSON Lines) คือรูปแบบข้อความที่จัดระเบียบบันทึก JSON เป็นรายบรรทัด จุดเด่นหลักไม่ได้อยู่ที่ว่า «หน้าตาคล้าย JSON» แต่อยู่ที่ว่า «แต่ละบันทึกอยู่บนบรรทัดของตัวเอง» ในทางวิศวกรรมจริง สิ่งนี้มักปรากฏเป็น «ทุกบรรทัดที่ไม่ว่างคืออ็อบเจ็กต์ JSON ที่สมบูรณ์» โดยอ็อบเจ็กต์ต่าง ๆ คั่นด้วยการขึ้นบรรทัด แทนที่จะนำไปห่อเพิ่มในอาร์เรย์ใหญ่ `[{...},{...}]`

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

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

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

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

  • จัดระเบียบ JSONL ที่ส่งออกมาจากล็อกแอปพลิเคชันทีละรายการให้อ่านง่าย ก่อนไล่ตรวจสอบทีละฟิลด์ แทนที่จะนั่งจ้องก้อนอ็อบเจ็กต์ยาว ๆ ที่ถูกอัดรวมเป็นบรรทัดเดียว
  • ตรวจไฟล์เก็บถาวรเซสชันที่แต่ละบรรทัดเป็นอ็อบเจ็กต์เหตุการณ์หนึ่งรายการ ยืนยันว่าทุกบันทึกสมบูรณ์และอ่านได้
  • เมื่อการส่งออกจำนวนมากจากไปป์ไลน์ข้อมูล แพลตฟอร์มติดตามผล หรือ Elasticsearch ล้มเหลว ให้ค้นหาอย่างรวดเร็วว่าอ็อบเจ็กต์ JSON บรรทัดไหนเขียนผิด
  • ขณะดีบักอินเทอร์เฟซที่คืนค่าแบบสตรีม ให้ตรวจว่าฝั่งเซิร์ฟเวอร์ผลิต «หนึ่งอ็อบเจ็กต์ต่อบรรทัด» อย่างต่อเนื่องจริง ๆ ไม่ใช่คืนอ็อบเจ็กต์ครึ่งเดียวออกมาก่อนเวลา
  • วาง NDJSON ที่คัดลอกมาจากเทอร์มินัล แผงควบคุมการมอนิเตอร์ หรือแพลตฟอร์มล็อกบนคลาวด์ จัดโครงสร้างให้เรียบร้อยก่อน แล้วค่อยสืบสวนต่อ
  • ตรวจว่าในผลลัพธ์อ็อบเจ็กต์ทีละบรรทัดที่ AI สร้าง มีบรรทัดไหนปนอาร์เรย์ สตริง หรือ JSON ที่ไม่สมบูรณ์เข้ามาหรือไม่
  • ก่อนนำเข้าสู่กระบวนการที่อาศัยบันทึกระดับบรรทัดอย่าง ClickHouse, BigQuery หรือ Kafka Connect ให้ตรวจทานเนื้อหา JSONL ด้วยตนเองก่อน
  • ขณะตรวจทานล็อกการตรวจสอบ เหตุการณ์ความเสี่ยง หรือสตรีมเหตุการณ์ติดตามผล ให้ดูทีละรายการว่าโครงสร้างอ็อบเจ็กต์คงที่และสอดคล้องกันหรือไม่
  • เมื่อไฟล์ JSONL ถูกตัดค้างหรือดาวน์โหลดไม่ครบ ให้มองเห็นได้ทันทีว่าอ็อบเจ็กต์รายการสุดท้ายรายการไหนยังไม่ถูกปิด
  • จัดรูปแบบ JSON คั่นบรรทัดที่เครื่องมือภายในส่งออกมาก่อน แล้วค่อยส่งให้เพื่อนร่วมงานรีวิวโค้ดหรือตรวจเทียบข้อมูล
  • ก่อนเขียนสคริปต์แยกวิเคราะห์ JSONL ให้ยืนยันระดับฟิลด์ อ็อบเจ็กต์ซ้อน และตำแหน่งอาร์เรย์ด้วยตนเองก่อน เพื่อลดเวลาดีบักสคริปต์
  • เวลาจัดการไฟล์ส่งออกเก่าที่ปนบรรทัดว่างกับบรรทัดเสีย ให้กรองปัญหาโครงสร้างออกก่อน แล้วค่อยตัดสินใจว่าจะแปลงเป็น CSV หรือนำเข้าฐานข้อมูลต่อหรือไม่

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

  1. วางเนื้อหา JSONL หรือ NDJSON ลงในพื้นที่ป้อนข้อมูล โดยให้ทุกบรรทัดที่ไม่ว่างเป็นอ็อบเจ็กต์ JSON ที่เป็นอิสระต่อกัน
  2. ทางขวาจะจัดรูปแบบทีละบรรทัดทันที และที่บรรทัดเสียจะระบุหมายเลขบรรทัด ข้อความแสดงข้อผิดพลาด และบันทึกเดิมไว้
  3. แก้บรรทัดที่เกี่ยวข้องตามคำแนะนำ จนกว่าจำนวนบรรทัดที่ผิดจะลดลงเป็นศูนย์
  4. เมื่อยืนยันว่าถูกต้องทั้งหมดแล้ว ค่อยคัดลอกผลลัพธ์ที่จัดรูปแบบทั้งหมด หรือส่งข้อมูลต่อไปยังสคริปต์ ตัวนำเข้า และกระบวนการวิเคราะห์ถัดไป

คุณสมบัติ

  • แยกวิเคราะห์ JSONL / NDJSON ทีละบรรทัด โดยไม่ต้องนำข้อมูลไปห่อเป็นอาร์เรย์ JSON เต็มรูปแบบแบบ `[{...},{...}]` ด้วยตนเองก่อน
  • ตรวจสอบตามความหมายของไฟล์จริงที่ว่า «ทุกบรรทัดที่ไม่ว่างคือหนึ่งอ็อบเจ็กต์ JSON» ซึ่งตรงกับรูปแบบข้อมูลทั่วไปอย่างล็อก สตรีมเหตุการณ์ และไฟล์เก็บเซสชัน
  • เลย์เอาต์สองคอลัมน์: ช่องป้อนข้อมูล `textarea` ทางซ้าย และผลลัพธ์ที่จัดรูปแบบทันทีทางขวา เหมาะกับการแก้ไปดูไป
  • บรรทัดที่เสียจะระบุหมายเลขบรรทัด ข้อผิดพลาดการแยกวิเคราะห์ และเนื้อหาเดิมไว้โดยตรง ช่วยซ่อมบันทึกที่ถูกตัด วงเล็บที่หายไป และข้อผิดพลาดจากการต่อกันได้อย่างรวดเร็ว
  • เปิดให้คัดลอกก็ต่อเมื่อทุกบรรทัดที่ไม่ว่างถูกต้องทั้งหมด เพื่อไม่ให้ข้อมูลที่สำเร็จบางส่วนและเสียบางส่วนถูกส่งต่อไปยังกระบวนการถัดไป
  • มีสถิติในตัวสำหรับจำนวนบรรทัดทั้งหมด บรรทัดที่ไม่ว่าง บรรทัดที่ถูกต้อง และบรรทัดที่ผิด ช่วยประเมินได้เร็วว่าในไฟล์ใหญ่มีบันทึกเสียกี่รายการ
  • มีข้อมูลตัวอย่างให้ ลองใช้การจัดรูปแบบ JSONL ได้ทันทีตั้งแต่เปิดครั้งแรก
  • การประมวลผลทั้งหมดเกิดขึ้นในเครื่องภายในเบราว์เซอร์ ล็อก เหตุการณ์เซสชัน และเนื้อหาที่ส่งออกจาก API จะไม่ถูกอัปโหลด

ตัวจัดรูปแบบ JSONL vs ตัวจัดรูปแบบ JSON vs ตัวซ่อม JSON

เครื่องมือเหล่านี้มักถูกใช้ต่อกัน แต่แก้ปัญหาคนละเรื่อง การเลือกทางเข้าให้ถูกจะช่วยประหยัดเวลาได้มาก

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

Best Practices

ขณะดีบักให้คงรูปแบบ JSONL เดิมไว้ อย่าห่อเป็นอาร์เรย์ด้วยตนเองเพียงเพื่อให้เข้าใจง่าย

หากระบบปลายทางเดิมรับ JSONL ให้พยายามตรวจสอบในรูปแบบเดิมที่เป็น «หนึ่งบันทึกต่อบรรทัด» การห่อเป็นอาร์เรย์แม้จะป้อนให้ตัวจัดรูปแบบทั่วไปได้ แต่จะสูญเสียความหมายของหมายเลขบรรทัดเดิม และโยงกลับไปยังตำแหน่งบรรทัดเสียจริงได้ยากขึ้น

ไฟล์ใหญ่ให้ดูบรรทัดท้าย ๆ ก่อนเป็นอันดับแรก

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

หากอินพุตมีเครื่องหมายคำพูดเดี่ยว คอมเมนต์ หรือสไตล์ JSON5 ให้ผ่านตัวซ่อม JSON ก่อนจะประหยัดเวลากว่า

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

เมื่อเตรียมนำเข้าใหม่ จงรักษาความหมายการขนส่งแบบ «หนึ่งอ็อบเจ็กต์ต่อบรรทัด» ไว้ให้ได้

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

ใช้หมายเลขบรรทัดเป็นเบาะแสหลัก แทนที่จะอ่านทั้งไฟล์ด้วยตาเปล่า

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

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

JSON กับ JSONL ต่างกันอย่างไร?

JSON ทั่วไปมักเป็นอ็อบเจ็กต์หรืออาร์เรย์ก้อนเดียวที่ต้องแยกวิเคราะห์รวมเป็นเอกสารเดียวทั้งหมด ส่วน JSONL (JSON Lines หรือที่มักเรียกว่า NDJSON) จะเก็บหนึ่งบันทึกอิสระต่อหนึ่งบรรทัด และในทางปฏิบัติเชิงวิศวกรรมที่พบบ่อยที่สุดคือ «หนึ่งอ็อบเจ็กต์ JSON ต่อหนึ่งบรรทัด» เหมาะกับล็อก สตรีมเหตุการณ์ การประมวลผลแบบสตรีม และการนำเข้าจำนวนมากมากกว่า เพราะอ่าน เขียน และระบุตำแหน่งข้อผิดพลาดได้ทีละบรรทัด

เหตุใดหน้านี้จึงเน้นย้ำเรื่อง «หนึ่งอ็อบเจ็กต์ JSON ต่อหนึ่งบรรทัด»?

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

JSONL ต่างจากอาร์เรย์ JSON แบบ `[{...},{...}]` อย่างไร?

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

เหตุใดบรรทัดว่างจึงถูกละเว้น?

บรรทัดว่างมักมาจากการคัดลอกวาง การหมุนล็อก หรือการแก้ไขด้วยตนเอง และไม่ได้แสดงถึงบันทึกข้อมูลจริง การละเว้นบรรทัดว่างช่วยลดสัญญาณรบกวน ขณะเดียวกันก็ยังคงตรวจทุกบรรทัดที่มีเนื้อหาอย่างเข้มงวด

ถ้าบรรทัดหนึ่งเป็นอาร์เรย์ สตริง หรือ `null` จะเกิดอะไรขึ้น?

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

เหตุใดเมื่อมีบรรทัดเสียหนึ่งบรรทัดจึงคัดลอกผลลัพธ์ทั้งหมดไม่ได้?

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

มันช่วยฉันค้นพบไฟล์ล็อกที่ถูกตัดค้างได้ไหม?

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

JSONL กับ NDJSON เป็นอย่างเดียวกันไหม?

ในบริบทเชิงวิศวกรรมส่วนใหญ่สามารถถือเป็นคำพ้องความหมายได้ ทั้งคู่หมายถึงบันทึก JSON ที่คั่นด้วยการขึ้นบรรทัด ต่างกันแค่ธรรมเนียมการตั้งชื่อ

ตอนจัดรูปแบบ JSONL ข้อมูลของฉันถูกอัปโหลดไหม?

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

เมื่อไรควรใช้ตัวจัดรูปแบบ JSON ทั่วไปแทนตัวจัดรูปแบบ JSONL?

หากอินพุตของคุณเป็นอ็อบเจ็กต์ JSON ที่สมบูรณ์หนึ่งรายการหรืออาร์เรย์อยู่แล้ว เช่น เนื้อหาการตอบกลับ API ไฟล์คอนฟิกูเรชัน หรือชุดข้อมูลแบบ `[{...},{...}]` ก็ควรใช้หน้าจัดรูปแบบ JSON ทั่วไป; เฉพาะเมื่ออินพุตเป็นบันทึกอ็อบเจ็กต์ที่แยกด้วยการขึ้นบรรทัด หน้า JSONL นี้จึงเหมาะสมกว่า

อภิธานศัพท์

JSONL
รูปแบบข้อความที่บันทึก JSON คั่นด้วยการขึ้นบรรทัด รูปแบบเชิงวิศวกรรมที่พบบ่อยที่สุดคือทุกบรรทัดที่ไม่ว่างเป็นอ็อบเจ็กต์ JSON ที่สมบูรณ์
JSON Lines
ชื่อเต็มของ JSONL และอีกชื่อหนึ่งที่เรียกกันทั่วไป โดยปกติถือเป็นคำพ้องความหมายกับ JSONL
NDJSON
Newline Delimited JSON แปลตรงตัวว่า «JSON ที่คั่นด้วยการขึ้นบรรทัด» ในสถานการณ์ล็อกและไปป์ไลน์ข้อมูลส่วนใหญ่ถือว่าเทียบเท่ากับ JSONL
บันทึกรายบรรทัด
การจัดวางข้อมูลที่แต่ละบรรทัดแทนหนึ่งบันทึกที่สมบูรณ์ เหมาะกับการเขียนและอ่านแบบสตรีมและการระบุข้อผิดพลาดตามบรรทัด
Pretty Print / การจัดรูปแบบให้อ่านง่าย
การจัดเรียง JSON ที่ถูกบีบเป็นบรรทัดเดียวใหม่ให้เป็นโครงสร้างที่อ่านได้พร้อมการเยื้องและขึ้นบรรทัด เพื่อให้ดูลำดับชั้นฟิลด์ด้วยตาได้ง่าย
บรรทัดเสีย
บรรทัดที่ไม่ใช่ JSON ที่ถูกต้อง หรือแม้จะแยกวิเคราะห์ได้แต่ไม่ตรงกับโครงสร้างที่คาดหวัง (เช่น ไม่ใช่อ็อบเจ็กต์) จึงไม่อาจเป็นบันทึก JSONL ที่ถูกต้องได้
สตรีมที่ถูกตัดค้าง
ล็อกหรือการส่งออกที่ถูกขัดจังหวะกลางคันระหว่างการส่ง การฟลัช หรือการบันทึก ทำให้บันทึกสุดท้ายไม่ถูกปิดอย่างสมบูรณ์
อาร์เรย์ JSON
ใน JSON มาตรฐาน คือชุดข้อมูลทั้งก้อนที่อยู่ระหว่าง `[` กับ `]` เช่น `[{...},{...}]` ต่างจาก JSONL ตรงที่ต้องแยกวิเคราะห์เป็นเอกสารเดียวทั้งก้อน

Authoritative References