Parse JSON khi dữ liệu chưa tới đủ: xem trước dạng streaming và sửa lỗi tăng dần
Kết luận: Mô hình LLM nhả JSON từng token, API trả về phản hồi lớn theo từng khối, nhưng JSON.parse lại từ chối làm việc cho tới khi toàn bộ tài liệu về đủ. Bài viết này tách ba kiểu triển khai — sửa toàn phần, tăng dần thật sự và phân tích một phần — cho biết mask Allow giữ cho bản xem trước ổn định thế nào, kèm số liệu đo pipeline và code sẵn sàng cho production.

JSON.parsehứa «chờ toàn bộ tài liệu về mới bắt đầu», còn streaming hứa «đưa dữ liệu từng khối một». Mâu thuẫn không nằm ở tốc độ mà nằm ở ngữ nghĩa tính đầy đủ: một tài liệu chưa viết xong vẫn chưa có «kết quả phân tích đúng» nào để nói.
Hiện tượng: ba kịch bản không thể chờ toàn văn
Kịch bản thứ nhất là ứng dụng LLM. Model nhả JSON từng token; một output có cấu trúc 8KB có thể mất hàng chục giây mới về hết trong lúc người dùng nhìn ô đợi trống trơn — dù những field đầu đã có thể hiển thị từ giây thứ nhất. Kịch bản thứ hai là gateway và proxy: upstream đẩy một phản hồi hàng chục MB qua các HTTP chunk, và proxy muốn lọc field trước khi chuyển tiếp sẽ nhân đôi đỉnh bộ nhớ nếu buffer toàn bộ bằng res.json(). Kịch bản thứ ba là message queue và log pipeline: các bản ghi NDJSON đến nối tiếp nhau, consumer không muốn gom batch.
Điểm chung rất rõ: dữ liệu đến dần dần, còn parser chuẩn chỉ nhận tài liệu hoàn chỉnh. JSON.parse ném Unexpected end of JSON input ngay từ khối 1, vẫn ném đúng lỗi đó ở khối 65 và chỉ trả kết quả ở khối cuối. Chờ đợi không phải lựa chọn duy nhất — nhưng trước hết bạn phải trả lời được: «parse» một tài liệu chưa viết xong nghĩa là gì.
Ngữ nghĩa phân tích theo tiền tố: khối nào cũng hợp lệ hay không
Lấy một mảng đơn hàng 7847 byte, cắt thành các khối 120 ký tự để mô phỏng dữ liệu đến dạng streaming (Node v22.13.1, jsonrepair 3.15.0, partial-json 0.1.7), rồi chạy ba parser trên từng tiền tố:
| Cách parse | Số lần thành công trên 66 tiền tố | Thời gian cộng dồn | Ngữ nghĩa |
|---|---|---|---|
JSON.parse |
1 (chỉ khối cuối) | 2,1 ms | được tất cả hoặc không có gì |
partial-json (Allow.ALL) |
66 (từ khối 1) | 14,3 ms | luôn trả về «đã biết tới đây» |
jsonrepair chạy lại toàn phần từng tiền tố |
66 | 23,8 ms | parse được sau khi đóng ngoặc, nhưng tính lại từ đầu mỗi lần |
Hai kết luận quan trọng. Thứ nhất, thất bại của JSON.parse không mang theo thông tin nào: vị trí báo lỗi luôn là cuối, bạn không biết còn thiếu bao nhiêu cũng như phần đã nhận có tự nhất quán hay không. Thứ hai, chạy lại sửa lỗi toàn phần trên từng tiền tố làm được nhưng không đáng: độ dài văn bản trung bình mỗi lần gọi tăng tuyến tính, chi phí cộng dồn tăng theo O(n²). 23,8 ms trông vô hại; khi văn bản lên cỡ megabyte, chính hệ số đó biến thành những giây CPU bị đốt vô ích.
Còn một lưu ý: «parse được theo tiền tố» không đồng nghĩa «dữ liệu đầy đủ». Con số cuối của tiền tố đã đóng ngoặc có thể bị khối tiếp theo viết tiếp, chuỗi cuối có thể bị cắt giữa dãy escape — đó chính là gốc rễ của mọi vấn đề ổn định khi xem trước streaming.
Ba kiểu triển khai phân công thế nào
Các thư viện phía streaming chia thành ba tư thế, và chọn sai tư thế còn tổn thương hơn chọn sai thư viện:
| Thư viện | Tư thế | Phù hợp | Không phù hợp |
|---|---|---|---|
jsonrepair (3.15.0) |
sửa toàn phần + Transform stream | bạn nhận «tài liệu rồi sẽ về đủ» và cần kết quả không mất mát | chỉ cần xem trước (output là cả khối văn bản đã sửa, không phải object dữ liệu) |
partial-json (0.1.7) |
phân tích một phần, cho phép bỏ phần đuôi chưa xong | xem trước UI: mỗi tiền tố đều có ngay một object dùng được | ghi xuống database (bản xem trước có thể thiếu field, số không ổn định) |
jsonmend (0.1.3) |
tăng dần thật sự, mở corpus nhất quán công khai | pipeline kiểu «vào một đoạn, ra một phiên bản» không quét lại phần trước | tài liệu đã kết thúc (parse toàn phần nhanh hơn) |
Ba bên không phải đang cạnh tranh. jsonrepair export jsonrepairTransform qua subpath ./stream, một Transform stream chuẩn: đẩy khối vào bên trái, bên phải ra các khối văn bản JSON đã sửa, và được đảm bảo nối lại sẽ bằng kết quả parse toàn văn một lần — bất đẳng thức decode(encode(x)) === x nó giữ được. partial-json giữ một mũi khác: mỗi tiền tố đều trả object ngay lập tức, đổi lại là từ bỏ lời hứa «kết quả cuối cùng không đổi». jsonmend ràng buộc mũi thứ ba bằng corpus nhất quán công khai: tăng dần thật sự, ngữ nghĩa có thể đối chiếu, cả hai phía triển khai dùng chung một bộ hồi quy.
Mask Allow: field nào dám hiển thị trong bản xem trước
Cốt lõi của partial-json không phải «parse được đầu vào hỏng tùy ý», mà là phía gọi tự khai báo sẵn chấp nhận mức thiếu nào. Mask ghép theo bit theo từng loại JSON (STR, NUM, ARR, OBJ…); bỏ đi một loại, giá trị chưa hoàn tất thuộc loại đó sẽ không vào bản xem trước:
import { parse, Allow } from 'partial-json';
parse('{"price": 12', Allow.ALL);
// → { price: 12 } số 12 là «đọc được tới đây»
parse('{"price": 1234.5', Allow.ALL);
// → { price: 1234.5 } cùng field đó đã đổi: bản xem trước không ổn định
parse('{"price": 12', Allow.ALL & ~Allow.NUM);
// → {} bỏ bit NUM, số chưa hoàn tất sẽ không hiển thị
Đây là quan sát có giá trị kỹ thuật nhất trong lần đo: các con số như giá, bộ đếm có thể bị viết tiếp sẽ đổi trên UI theo từng frame; còn Allow.ALL & ~Allow.NUM bảo chúng im lặng chờ tới khi viết xong mới xuất hiện. Chuỗi cũng vậy — chuỗi bị cắt giữa dãy escape Unicode, partial-json 0.1.7 bỏ một cách an toàn thay vì đoán mò. Sự ổn định của bản xem trước không phải do parser ban tặng; người gọi phải mua nó bằng mask.
Chi phí hiện thực sửa lỗi streaming: look-back buffer và sao chép bậc hai
Pipeline streaming không phải bọc API toàn phần trong một vòng for. Trên cùng mẫu 66 khối, pipeline với jsonrepairTransform tổng cộng 6,7ms, còn chạy lại sửa toàn phần từng tiền tố cộng dồn 23,8ms — khoảng cách 3,5 lần đến từ tầng hiện thực: bản streaming chỉ nhìn lại trong cửa sổ cần thiết, output ghi thêm bằng buffer tăng dần, không sao chép lại phần trước vô số lần.
Việc port nhân streaming của jsonrepair lên HarmonyOS ArkTS (thực tiễn port thư viện bên thứ ba của openHarmony) đã vạch ra ba chi phí cụ thể: đường streaming phía upstream cần gom «look-back buffer», nên với tài liệu nhỏ kết quả phải chờ flush — tác giả vì thế viết riêng một IncrementalRepairer cho văn bản ngắn xem-và-đợc theo dòng; đường regular phía upstream sao chép toàn bộ output nhiều lần, có tính bậc hai, và khi port thì OutputBuilder đã gỡ nó; và còn một cạm bẫy ký tự biên — điều kiện text[i] === undefined để thử «đã đọc tới cuối» khi đổi sang charAt sẽ bị lừa, vì ''.includes('') luôn là true, nên vượt biên phải chặn trước bằng chuỗi rỗng. Những chi tiết này giải thích vì sao «sửa lỗi streaming» xứng đáng có một ô phân loại riêng: mức phức tạp kỹ thuật của nó và sửa lỗi một lần không cùng một bậc.
Cũng nên ghi nhận biên đã biết: issue #214 của jsonrepair báo rằng sửa lỗi streaming từ chối tiền tố hợp lệ thiếu dấu phẩy trước giá trị có slash — trong chế độ streaming, về mặt từ vựng khó phân biệt «ký tự kế tiếp chưa tới» với «đầu vào không hợp lệ»; cửa sổ look-back chính là cái giá phải trả cho sự mơ hồ này.
Triển khai thế nào: xem trước và ghi xuống đi hai đường
Ghép các ngữ nghĩa trên thành một pipeline; nguyên tắc gói gọn trong một câu: xem trước dùng phân tích một phần, ghi xuống dùng phân tích nghiêm ngặt.
import { jsonrepairTransform } from 'jsonrepair/stream';
import { parse as partialParse, Allow } from 'partial-json';
// Đường 1: pipeline không mất mát. Vào: các khối, ra: văn bản JSON đã sửa, cuối cùng kiểm tra nghiêm ngặt
const tr = jsonrepairTransform();
tr.pipe(finalSink); // finalSink sẽ làm JSON.parse + kiểm tra nghiệp vụ
chunkStream.pipe(tr);
// Đường 2: pipeline xem trước. Mỗi tiền tố cho một frame UI; số và chuỗi chưa xong bị mask giữ lại
function onChunk(buffer) {
const preview = partialParse(buffer, Allow.ALL & ~Allow.NUM & ~Allow.STR);
render(preview); // chỉ vẽ field ổn định; field thay nhanh để chờ
}
Hợp đồng của hai đường khác nhau và không thay thế được nhau: frame xem trước được phép thiếu field, frame ghi xuống thì không; frame ghi xuống phải đợi stream kết thúc và chạy một lượt JSON.parse đầy đủ kèm kiểm tra nghiệp vụ, còn frame xem trước không bao giờ ghi xuống. Nếu upstream là output của LLM, trước khi ghi xuống cần đánh giá theo stop_reason xem có bị cắt cụt hay không — quy trình «nhìn stop_reason trước rồi mới nói đến sửa lỗi» đã được trình bày trong bài sửa JSON bị cắt cụt từ LLM, ở đây không nhắc lại.
Khi nào đừng làm streaming
Ba điều kiện phủ quyết; trúng một điều kiện thôi thì hãy cứ parse toàn phần: tệp nhỏ — JSON.parse thường cho tới ~22MB đọc một lần trong dưới một giây, streaming chỉ thêm code; chỉ tính toán một lần — tổng hợp dùng jq --stream hoặc NDJSON theo dòng tiện hơn, xem cẩm nang thực hành JSONL; bên tiêu thụ không nhận dữ liệu một phần — ví dụ tổng tiền, một kết quả trung gian sai nhân trong bản xem trước là thiệt hại tiền thật; lúc đó streaming chỉ còn giá trị «thanh tiến trình».
Phân tích streaming giải quyết luôn là «không thể chờ», không phải «nhanh hơn». Cùng lượng văn bản, tổng CPU của parse toàn phần luôn nhỏ hơn mọi phương án streaming; bạn đổi lấy là thời gian đến byte đầu dùng được và mực bộ nhớ không đổi. Xác định rõ sự đánh đổi này thì việc chọn công nghệ sẽ không còn lảo đảo.
Câu hỏi thường gặp
Có thể ghi object xem trước thẳng vào database không?
Không. Bản xem trước là ảnh chụp của «đã biết tới đây»: số có thể bị viết tiếp, chuỗi có thể bị cắt, field có thể tạm thời thiếu. Trước khi ghi xuống phải đợi stream kết thúc, chạy một lượt JSON.parse nghiêm ngặt trên toàn văn, rồi qua kiểm tra nghiệp vụ. Bản xem trước chỉ thuộc về tầng UI.
Chọn partial-json hay jsonrepair?
Phụ thuộc bạn muốn văn bản hay object. Văn bản đã sửa không mất mát (đưa đi parse tiếp) thì dùng jsonrepair — output streaming của nó bảo đảm khớp với parse toàn văn; object cho từng tiền tố hiển thị ngay lên UI thì dùng partial-json, và đặt mask Allow theo mức bất ổn bạn chịu được.
Phân tích streaming có giảm tổng thời gian không?
Không. Tổng CPU của parse toàn phần luôn nhỏ nhất, còn phương án streaming còn phải trả thêm chi phí duy trì trạng thái. Streaming đổi lại ba thứ: thời gian khối đầu dùng được, bộ nhớ không tăng theo độ dài toàn văn, và khả năng xử lý khi đang nhận (chuyển tiếp, lọc, hiển thị).
Các phần tử mảng đến từng cái mà muốn xử lý từng cái thì sao?
Đó là con đường khác: stream-json với streamArray ném {key, value} ngay khi phần tử đóng lại, và với for await tạo backpressure tự nhiên — hợp với import hàng loạt kiểu «parse rồi ghi», còn bài này nói về xem trước ở tầm cả tài liệu.