Pengformat JSON

Tampal JSON yang padat, dipintas, atau berselerak dan dapatkan output berinden sempurna secara serta-merta. Pemformat menganalisis JSON anda dengan JSON.parse asli pelayar (mengikut ECMA-404), mengekalkan aksara Unicode, dan memancarkan semula dengan indentasi pilihan anda:

• 2 ruang (lalai npm dan prettier)
• 4 ruang
• tab

Objek bersarang dan tatasusunan diinden dengan betul pada setiap kedalaman. Kunci, rentetan, nombor, boolean, dan null mendapat warna penyerlahan sintaks yang berbeza supaya anda boleh meneliti struktur sepintas lalu.

Label 'beautifier' boleh bertukar ganti dengan 'formatter' atau 'pretty printer' — semuanya menjelaskan operasi yang sama: menghasilkan JSON yang mudah dibaca manusia daripada input yang padat.

Pengesahan berjalan semasa anda menaip. Jika JSON anda gagal dianalisis, pemformat menunjukkan baris tepat, lajur, dan apa yang dijangkakan oleh penganalisis.

Pengesahan adalah ketat mengikut RFC 8259 (Piawaian Internet IETF) dan ECMA-404 — tiada komen, tiada koma di hujung, tiada petik tunggal, tiada kunci tanpa petik, tiada NaN, tiada Infinity, tiada undefined. Nilai aras teratas boleh jadi sebarang nilai JSON (objek, tatasusunan, rentetan, nombor, true, false, null).

Untuk input berkarakter UTF-8, pemformat menerima set aksara Unicode penuh; persekitaran ASCII sahaja perlu menggunakan penjejak \uXXXX.

Ralat biasa dan pembaikan:

• koma di hujung selepas elemen tatasusunan/objek terakhir (buangkannya)
• petik tunggal di sekeliling kunci atau rentetan (gantikan dengan petik ganda)
• kurungan penutup yang hilang (lajur ralat menunjuk berhampiran tempat terpotong)
• aksara kawalan tidak terlepas dalam rentetan (lepas dengan \n, \t, \\)

Pemintasan membuang semua ruang putih yang tidak penting — ruang antara token, indentasi, dan baris baharu — meninggalkan wakil sekemas yang mungkin. Penjimatan biasa ialah 20–60% bergantung pada sejauh mana JSON sumber anda diindenkan.

Gunakan JSON yang dipintas untuk:

• respons API REST/GraphQL
• mesej WebSocket
• muatan JWT
• blok konfigurasi SaaS
• atribut data terbenam dalam HTML

Kekalkan JSON yang diformat untuk:

• fail konfigurasi kawalan sumber
• kelengkapan dan tangkapan skrin dalam ujian
• dokumen yang diedit manusia

JSON yang dipintas masih 100% JSON standard — sebarang penganalisis patuh menerimanya. Pemintas di sini mengekalkan data dengan tepat: tiada penyusunan semula kunci, tiada paksaan nilai, tiada kehilangan kejituan pada nombor dalam julat IEEE 754 double.

Pengesahan sintaks JSON tulen hanya menyemak sama ada dokumen boleh dianalisis. JSON Schema mengesahkan bentuk dokumen — bahawa 'email' ialah rentetan, 'age' ialah integer 0–150, 'role' ialah salah satu daripada ['admin', 'user', 'guest']. Skema itu sendiri merupakan dokumen JSON yang menerangkan kekangan; sampel disahkan berbanding daripadanya.

Kata kunci biasa: type, required, properties, items, enum, pattern (regex), minimum/maximum, minLength/maxLength, format (email, date-time, uri).

Pelaksanaan rujukan:

• Ajv (JavaScript, terpantas)
• jsonschema (Python)
• networknt/json-schema-validator (Java)
• justinrainbow/json-schema (PHP)

Pengesahan skema mengesan pelbagai ralat pada sempadan API: medan diperlukan yang hilang, jenis yang salah, nilai luar julat, tarikh tidak sah. Spesifikasi OpenAPI 3.x menggunakan JSON Schema untuk pengesahan permintaan/respons.

JSONPath untuk JSON adalah seperti XPath untuk XML — bahasa kueri untuk menavigasi dan mengekstrak daripada JSON bersarang.

Sintaks:

• $ (akar)
• . (anak)
• .. (keturunan rekursif)
• [n] (indeks tatasusunan)
• [mula:akhir] (hirisan)
• [?(ungkapan)] (penapis)
• * (kad liar)

Contoh pada JSON kedai biasa:

• $.store.book[0].title mendapatkan tajuk buku pertama
• $..author mengembalikan setiap pengarang dalam dokumen
• $.store.book[?(@.price < 10)] menapis buku yang lebih murah daripada 10
• $.store..price[*] meratakan semua harga

Alatan: jq (sintaks sedikit berbeza tetapi keupayaan yang sama, dominan dalam skrip shell), skrip ujian Postman, JMESPath (--query AWS CLI), dan pustaka JSONPath dalam setiap bahasa utama.

JSON Lines (jsonlines.org), juga dikenali sebagai NDJSON atau LDJSON, ialah format di mana setiap baris merupakan nilai JSON yang lengkap. Keseluruhan fail ini bukanlah JSON yang sah — tetapi setiap baris secara individu adalah sah.

Digunakan secara meluas untuk penstriman log (Loki, Splunk HEC, Vector), saluran paip ETL, data latihan pembelajaran mesin (fail penalaan halus OpenAI), dan sebarang aliran data tambah sahaja (append-only).

Kelebihan:

• mesra penstriman (menganalisis satu rekod pada satu masa, memori tetap)
• tambah sahaja (hanya tulis baris seterusnya)
• boleh digrep dan diawk dengan alat Unix standard

Sambungan fail: .jsonl, .ndjson. Tukar daripada tatasusunan JSON dengan `jq -c '.[]'`; tukar kepada tatasusunan JSON dengan `jq -s` (slurp). BigQuery, Athena, Snowflake, dan kebanyakan gudang data moden memasukkan NDJSON secara asli.

JSON5 (json5.org) memperluaskan JSON dengan kemudahan untuk pembangun:

• komen (// dan /* */)
• koma di hujung (trailing commas)
• rentetan dalam petik tunggal
• kunci tanpa tanda petik
• rentetan berbilang baris (dengan penanda sambungan garis condong ke belakang)
• nombor heksadesimal
• nilai khas IEEE 754 (NaN, Infinity)

Ia TIDAK serasi dengan JSON.parse — anda memerlukan penganalisis sintaks (parser) JSON5 (pakej npm json5, PyJson5).

Gunakan JSON5 untuk fail konfigurasi yang disunting oleh manusia di mana komen adalah berharga: babel.config.json5, sesetengah konfigurasi alat binaan, .vscode/settings.json (yang menggunakan JSONC, dialek JSON-dengan-komen yang serupa).

Kekal dengan JSON ketat untuk: API HTTP, pertukaran data, format penyimpanan, dan apa-apa sahaja yang dijana mesin. Mencampurkan kedua-duanya mengelirukan alatan — pilih satu per fail dan kekalkan dengannya.

Ralat analisis sintaks JSON yang paling kerap berlaku dan penyelesaiannya:

• (1) Koma di hujung selepas elemen terakhir — `{"a":1,}` atau `[1,2,3,]` — buang koma tergantung tersebut.
• (2) Petik tunggal pada kunci atau nilai rentetan — `{'name':'Alice'}` — mesti menggunakan petik ganda.
• (3) Kunci tanpa tanda petik — `{name:"Alice"}` — letakkan tanda petik.
• (4) Komen menggunakan // atau /* */ — JSON ketat tidak membenarkannya; buang atau tukar kepada JSON5/JSONC.
• (5) Nilai JavaScript yang tidak wujud dalam JSON — undefined, NaN, Infinity, fungsi — gantikan dengan null atau buang.
• (6) Input terpotong — penganalisis sintaks biasanya menunjuk ke baris di mana ia kehabisan kandungan yang dijangkakan.
• (7) BOM (markah urutan bait) di permulaan fail UTF-8 — kebanyakan penganalisis menolaknya; buang dengan `sed -i '1s/^\xEF\xBB\xBF//'`.
• (8) Campuran tab dan jarak tidak merosakkan analisis tetapi merosakkan diff — pilih satu gaya inden.

Tiga kategori kerentanan berkaitan JSON yang perlu difahami oleh setiap pembangun.

• (1) Pencemaran prototip (prototype pollution): menggabungkan JSON yang tidak dipercayai ke dalam objek sedia ada boleh mencemarkan Object.prototype jika input mengandungi kunci __proto__, constructor, atau prototype — menjejaskan setiap objek dalam persekitaran pelaksanaan (runtime). Gunakan Object.create(null), structuredClone, atau pustaka seperti defaultsDeep milik lodash yang menyekat kunci ini secara eksplisit.
• (2) Jangan sekali-kali menggunakan eval() untuk menganalisis JSON — eval mengeksekusi sebarang JavaScript, manakala JSON.parse diasingkan dalam persekitaran terhad (sandboxed). Mitos bahawa 'eval lebih pantas' telah disangkal bertahun-tahun dahulu.
• (3) Perangkap penulisan semula siri (re-serialization): JSON.stringify secara senyap mengabaikan fungsi, undefined, dan nilai Symbol daripada objek (menukarkannya kepada null dalam tatasusunan). Ia juga melempar ralat pada rujukan bulat (circular references) dan BigInt secara lalai.

Sahkan JSON yang tidak dipercayai dengan JSON Schema sebelum memprosesnya, tetapkan saiz badan maksimum pada API anda, dan gunakan semakan Content-Type untuk menolak input bukan JSON dari awal. Lembaran Imbasan Keselamatan REST OWASP merangkumi gambaran penuh.

JSON ↔ YAML ialah penukaran yang paling sedikit kehilangan maklumat — kedua-duanya menyokong objek/tatasusunan bersarang. Berhati-hati dengan paksaan jenis automatik YAML (yes/no/on/off menjadi boolean, nombor tanpa petik kekal nombor, rentetan 'null' menjadi null) — letakkan tanda petik pada nilai yang samar. Alat: js-yaml (npm), PyYAML, yq.

JSON → CSV memerlukan perataan struktur bersarang — berfungsi paling baik untuk tatasusunan objek rata. Pilih strategi untuk nilai bersarang: stringify (tulis sebagai JSON dalam sel) atau lajur notasi titik (`address.city`, `address.zip`). Alat: in2csv csvkit, pandas pd.json_normalize, json2csv (npm).

JSON → XML adalah mudah untuk struktur pokok tetapi kehilangan perbezaan antara tatasusunan vs objek — elemen selevel (siblings) XML boleh jadi salah satu daripadanya. Berhati-hati dengan nama elemen XML yang tidak sah (tidak boleh bermula dengan digit, tidak boleh mengandungi ruang jarak). Alat: xml-js, xmltodict (Python).

Untuk semua penukaran, buat keputusan terlebih dahulu sama ada anda ingin mengekalkan maklumat jenis data atau meratakan segala-galanya menjadi rentetan.

JSON.parse memuatkan keseluruhan dokumen ke dalam memori — tiada masalah untuk respons API biasa, tetapi bermasalah untuk fail melebihi beberapa ratus MB. Penganalisis penstriman memproses satu token (atau satu rekod) pada satu masa, mengekalkan penggunaan memori tetap tanpa mengira saiz fail.

• JavaScript: stream-json atau oboe.js untuk analisis gaya SAX.
• Python: ijson untuk analisis berperingkat (incremental), atau tukar kepada JSON Lines terlebih dahulu dan baca baris demi baris.
• Java: Jackson Streaming API (JsonParser).
• Shell: jq memproses penstriman JSON melalui --stream.

Untuk fail yang dijana sebagai tatasusunan rekod JSON, pertimbangkan untuk mengubah pengeluar bagi mengeluarkan JSON Lines — setiap pengguna hiliran akan mendapat manfaat. Apabila anda perlu mengendalikan tatasusunan JSON yang sangat besar dalam memori, lebih baik melakukan lelaran (iteration) dan membuang rekod daripada membina struktur data selari. Perhatikan saiz heap, tetapkan --max-old-space-size dalam Node, dan lakukan pemprofilan (profiling) sebelum membuat pengoptimuman.

Rujukan pantas untuk tugasan JSON harian.

• Inden: prettier dan npm ditetapkan secara lalai kepada 2 ruang jarak; pilih 4 untuk kod asas perusahaan yang sedia ada menggunakan inden 4 ruang jarak bagi pelbagai bahasa; tab adalah sah tetapi jarang digunakan dalam JSON.
• Susun kunci (untuk diff yang lebih bersih): JSON.stringify(obj, Object.keys(obj).sort(), 2) untuk objek cetek; jq --sort-keys untuk penataan semula mendalam (deep recursion); Python json.dumps(obj, sort_keys=True).
• Diff dua fail JSON: jalankan jq --sort-keys pada kedua-dua fail, kemudian jalankan diff biasa; atau guna json-diff (npm), DeepDiff (Python), fungsi perbandingan peka JSON terbina dalam VS Code.
• Urutan escape dalam rentetan: \\" (petik ganda), \\\\ (garis condong ke belakang), \\/ (garis condong ke depan, pilihan), \\b (backspace), \\f (form feed), \\n (baris baharu), \\r (carriage return), \\t (tab), \\uXXXX (titik kod Unicode).
• Nombor: JSON membenarkan perpuluhan dan eksponen (1.5e3) tetapi tiada sifar di hadapan (0123 tidak sah) dan tiada titik perpuluhan di hujung (1. tidak sah).
• Rentetan mesti menggunakan petik ganda — petik tunggal hanya untuk JSON5.