SSE เป็น JSON

SSE Stream
Blank line separates events0 lines0 chars
JSON Array0

Formatted JSON shows up here

Paste id/event/data blocks separated by blank lines on the left, and each event becomes one item of the JSON array.

0 eventsWaiting for input

ตัวแปลงที่เน้นเฉพาะข้อมูล push ของ Server-Sent Events (SSE) วางบล็อกดิบ id/event/data ทางด้านซ้าย แล้วทางด้านขวาจะแสดงอาร์เรย์ JSON มาตรฐานทันที โดยแต่ละเหตุการณ์ที่ถูก push จะกลายเป็นหนึ่งอ็อบเจ็กต์ที่มี id ชื่อเหตุการณ์ และ payload ข้อมูลที่แยกวิเคราะห์แล้ว

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

การแปลง SSE เป็น JSON คืออะไร?

Server-Sent Events (SSE) คือโปรโตคอลสตรีมทิศทางเดียวที่เซิร์ฟเวอร์เขียนเหตุการณ์ข้อความ UTF-8 ลงในการตอบกลับ HTTP ประเภท `text/event-stream` บนสายส่ง ทุกเหตุการณ์คือลำดับของบรรทัดฟิลด์เช่น `id: 1`, `event: MESSAGE` และ `data: {...}` และบรรทัดว่างจะทำเครื่องหมายจุดสิ้นสุดของเหตุการณ์นั้น

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

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

ผลลัพธ์คืออาร์เรย์ JSON มาตรฐานที่เยื้องได้สวยงาม อ่านง่าย คัดลอกลงโค้ดได้ เทียบกับการจับภาพอื่นได้ หรือป้อนเข้าเครื่องมือถัดไปได้ ในขณะที่ payload ที่แยกวิเคราะห์ไม่ได้จะถูกตั้งธงไว้ แทนที่จะถูกทิ้งไป

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

  • ดีบักการตอบกลับแบบสตรีมของ LLM หรือ AI agent ที่มาถึงเป็นชิ้นเหตุการณ์ SSE เช่น STREAM_CHUNK หรือ CHUNK_DELTA
  • เปลี่ยนการตอบกลับ text/event-stream ที่คัดลอกมาจากแท็บ Network ใน DevTools ของเบราว์เซอร์ให้เป็น JSON ที่อ่านได้
  • ตรวจสอบเหตุการณ์ heartbeat, ack และข้อความเต็มจากแบ็กเอนด์ push แบบเรียลไทม์หรือแชต
  • แปลงข้อมูล push SSE ที่จับไว้เป็นอาร์เรย์ JSON ก่อนส่งให้เพื่อนร่วมงานเพื่อดีบัก
  • ดึงและขยาย payload ข้อมูลที่ซ้อนกันของทุกเหตุการณ์ โดยไม่ต้องลบคำนำหน้า data: ด้วยตนเอง
  • เล่นสตรีม push ที่บันทึกไว้ซ้ำแบบออฟไลน์ และเปรียบเทียบลำดับเหตุการณ์ตาม id
  • เตรียมข้อมูลเหตุการณ์ SSE สำหรับการวิเคราะห์ ล็อก หรือสเปรดชีตที่คาดหวังอาร์เรย์ JSON
  • ตรวจสอบว่าระหว่างผสานงานฟรอนต์เอนด์กับแบ็กเอนด์ เซิร์ฟเวอร์ส่งชื่อเหตุการณ์และรูปร่าง payload ตามที่คาดไว้
  • แปลงฟิลด์ data หลายบรรทัดให้เป็นหนึ่งค่าที่แยกวิเคราะห์ต่อหนึ่งอ็อบเจ็กต์เหตุการณ์
  • ตรวจสอบร่องรอย SSE จากพร็อกซี เกตเวย์ หรือเอาต์พุต curl ในรูปแบบที่มีโครงสร้างและพับได้
  • แปลงสตรีมเหตุการณ์แบบ Webhook หรือจากคิวข้อความที่นำรูปแบบส่งผ่าน SSE มาใช้ซ้ำให้เป็น JSON
  • เรียนรู้รูปแบบส่งผ่านของ Server-Sent Events โดยเห็นว่า id, event และ data แปลงไปเป็นอ็อบเจ็กต์ JSON อย่างไร

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

  1. วางสตรีม SSE ดิบลงในพื้นที่ป้อนทางด้านซ้าย โดยให้มีบรรทัด id/event/data และบรรทัดว่างระหว่างเหตุการณ์
  2. ด้านขวาจะอัปเดตโดยอัตโนมัติและแสดงอาร์เรย์ JSON ที่มีหนึ่งอ็อบเจ็กต์ต่อหนึ่งเหตุการณ์
  3. ดูแผงคำเตือนหาก payload ข้อมูลใดไม่ใช่ JSON ที่ถูกต้อง หรือฟิลด์ใดดูผิดรูป
  4. ใช้คัดลอกเพื่อก๊อปปี้อาร์เรย์ JSON ทั้งหมด หรือใช้ตัวอย่างเพื่อโหลดตัวอย่างที่มากับเครื่องมือก่อน

คุณสมบัติ

  • แปลงสตรีมเหตุการณ์ SSE ดิบเป็นอาร์เรย์ JSON มาตรฐาน โดยมีหนึ่งอ็อบเจ็กต์ต่อหนึ่งเหตุการณ์ที่ถูก push
  • จัดกลุ่มบรรทัดเป็นเหตุการณ์ตามบรรทัดว่าง ตามโมเดลการแจกจ่ายของ Server-Sent Events
  • แยกวิเคราะห์แต่ละฟิลด์เป็น field: value และตัดช่องว่างหนึ่งช่องหลังโคลอนออก
  • แยกวิเคราะห์ payload ข้อมูลทุกรายการด้วย JSON.parse เพื่อให้ payload ที่ซ้อนกันกลายเป็นอ็อบเจ็กต์จริง ไม่ใช่สตริงที่ถูก escape
  • รักษาลำดับคีย์ id, event, data ให้คงที่ และแปลง id ที่เป็นตัวเลขให้เป็น JSON number
  • รองรับฟิลด์ data หลายบรรทัด บรรทัดคอมเมนต์ที่ขึ้นต้นด้วยโคลอน และสตรีมที่ไม่มีบรรทัดว่างท้ายสุด
  • รายงาน payload ข้อมูลที่ไม่ถูกต้องและฟิลด์ที่ไม่รู้จักหรือผิดรูป พร้อมหมายเลขบล็อกและหมายเลขบรรทัด
  • เลย์เอาต์แยกพื้นที่ป้อนข้อความและพรีวิว JSON พร้อมตัวอย่าง ล้าง คัดลอก และสถิติเหตุการณ์ ทำงานทั้งหมดในเบราว์เซอร์

SSE เป็น JSON vs ตัวจัดรูปแบบ JSONL vs ตัวจัดรูปแบบ JSON

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

เครื่องมืออินพุตที่เหมาะที่สุดความสามารถหลักสถานการณ์ที่ใช้
SSE เป็น JSONบล็อก id/event/data ที่แบ่งด้วยบรรทัดว่างเข้าใจฟิลด์ SSE และแยกวิเคราะห์แต่ละ payload ข้อมูลสตรีม push จากเซิร์ฟเวอร์, text/event-stream, ชิ้นสตรีมมิง AI
ตัวจัดรูปแบบ JSONLหนึ่งอ็อบเจ็กต์ JSON สมบูรณ์ต่อบรรทัดตรวจสอบและจัดรูปแบบแต่ละบรรทัดอย่างอิสระล็อก NDJSON, เหตุการณ์ที่เก็บถาวร, การส่งออกแบบคั่นด้วยบรรทัด
ตัวจัดรูปแบบ JSONหนึ่งอ็อบเจ็กต์หรืออาร์เรย์ JSON ที่สมบูรณ์จัดระเบียบเอกสาร JSON ทั้งฉบับให้อ่านง่ายการตอบกลับ API, ไฟล์คอนฟิก, payload ครั้งเดียว

Best Practices

คงบรรทัดว่างระหว่างเหตุการณ์ไว้เมื่อคัดลอกสตรีม

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

ใช้หมายเลขบล็อกและบรรทัดในคำเตือนเพื่อกระโดดไปยังปัญหา

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

จำไว้ว่ามีเพียงฟิลด์ data เท่านั้นที่ถูกแยกวิเคราะห์เป็น JSON

ฟิลด์ id, event และ retry เป็นเมตาดาต้าการส่งผ่านของ SSE และคงเป็นค่าสเกลาร์ไว้ อย่าคาดหวังว่าตัวแปลงจะแยกวิเคราะห์ JSON ที่ปรากฏในชื่อเหตุการณ์หรือ id เนื้อหาที่มีโครงสร้างควรอยู่ใน data

รวมชิ้นสตรีมมิงบางส่วนก่อนแปลงเป็นข้อความเต็มหนึ่งฉบับ

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

ฆ่าเชื้อ payload ที่ละเอียดอ่อนก่อนแชร์ JSON ที่แปลงแล้ว

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

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

SSE (Server-Sent Events) คืออะไร?

SSE คือวิธีมาตรฐานที่เซิร์ฟเวอร์ใช้ส่งเหตุการณ์ข้อความแบบ push ไปยังเบราว์เซอร์ผ่าน HTTP โดยใช้ประเภทเนื้อหา `text/event-stream` แต่ละเหตุการณ์ประกอบด้วยบรรทัดข้อความเช่น `id`, `event` และ `data` และเหตุการณ์ต่าง ๆ จะถูกแยกจากกันด้วยบรรทัดว่าง

เครื่องมือนี้แบ่งสตรีมออกเป็นเหตุการณ์อย่างไร?

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

เอาต์พุต JSON หน้าตาเป็นอย่างไร?

ผลลัพธ์คืออาร์เรย์ JSON หนึ่งชุด แต่ละเหตุการณ์นำเข้าจะกลายเป็นหนึ่งอ็อบเจ็กต์พร้อมฟิลด์ที่มีอยู่ ตามลำดับคงที่ id, event, data ข้อความ `data` จะถูกแยกวิเคราะห์ด้วย JSON.parse ดังนั้น payload อย่าง `data: {"a":1}` จะกลายเป็นอ็อบเจ็กต์ซ้อน `"data": {"a":1}` แทนที่จะเป็นสตริงที่ถูก escape

เหตุใด id จึงเป็นตัวเลขในเอาต์พุต?

ในทางเทคนิคแล้ว id ของ SSE เป็นสตริง แต่สตรีม push จริงมักใช้ id เป็นตัวเลขเกือบเสมอ เช่น `id: 0` เมื่อ id ประกอบด้วยตัวเลขเท่านั้น ตัวแปลงจะส่งออกเป็น JSON number ส่วน id อื่นใดจะคงเป็นสตริง

จะเกิดอะไรขึ้นเมื่อ data กินหลายบรรทัด?

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

ถ้า payload ข้อมูลไม่ใช่ JSON ที่ถูกต้องจะเป็นอย่างไร?

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

SSE เป็น JSON ต่างจากตัวจัดรูปแบบ JSONL อย่างไร?

JSONL มีหนึ่งอ็อบเจ็กต์ JSON สมบูรณ์ในทุกบรรทัด แต่ SSE กลับมีบรรทัด `id/event/data` ที่มีป้ายกำกับซึ่งถูกจัดกลุ่มเป็นเหตุการณ์ด้วยบรรทัดว่าง และมีเพียงส่วน data เท่านั้นที่เป็น JSON SSE เป็น JSON เข้าใจป้ายฟิลด์เหล่านี้และขอบเขตเหตุการณ์ที่เป็นบรรทัดว่าง ในขณะที่ตัวจัดรูปแบบ JSONL จะมองทุกบรรทัดอย่างอิสระ

ตัวแปลงนี้อัปโหลดข้อมูลสตรีมของฉันไหม?

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

อภิธานศัพท์

SSE
Server-Sent Events มาตรฐานสำหรับการสตรีม push ทิศทางเดียวจากเซิร์ฟเวอร์ไปยังไคลเอนต์ผ่าน HTTP
text/event-stream
ชนิดสื่อ MIME ของเนื้อหาการตอบกลับ SSE ซึ่งมีบรรทัดฟิลด์คั่นด้วยบรรทัดว่าง
บล็อกเหตุการณ์
กลุ่มของบรรทัดฟิลด์ที่ไม่ว่างต่อเนื่องกัน ซึ่งร่วมกันอธิบายหนึ่งเหตุการณ์ push และจบลงด้วยบรรทัดว่าง
ฟิลด์ data
ฟิลด์ SSE ที่บรรทุก payload ของเหตุการณ์ บรรทัด data หลายบรรทัดในหนึ่งเหตุการณ์จะถูกรวมด้วยการขึ้นบรรทัดใหม่ และมักเป็น JSON
ฟิลด์ event
ฟิลด์ตัวเลือกที่ใช้ตั้งชื่อประเภทเหตุการณ์ เมื่อไม่มีฟิลด์นี้ เบราว์เซอร์จะแจกจ่ายเป็นเหตุการณ์ทั่วไปชื่อ 'message'
ฟิลด์ id
ค่า last-event-id ตัวเลือกที่ใช้สำหรับกลับมาต่อสตรีม ตัวแปลงนี้จะส่งออก id ที่เป็นตัวเลขเป็น JSON number
ฟิลด์ retry
ฟิลด์ตัวเลือกที่บอกไคลเอนต์ถึงเวลารอก่อนเชื่อมต่อใหม่เป็นมิลลิวินาที ต้องมีเฉพาะตัวเลข ASCII เท่านั้น
บรรทัดคอมเมนต์
บรรทัดที่ขึ้นต้นด้วยโคลอน มักใช้เป็น heartbeat หรือ keep-alive และจะถูกละเว้นเมื่อสร้างเหตุการณ์

Authoritative References