Tungkol sa tool na ito
Ang pag-format ng JSON (madalas na tinatawag na pretty-printing o beautification) ay tumatagal ng compact na JSON at nagdaragdag ng whitespace — mga line break, indentation, pare-parehong spacing — para makita ng mga taong mambabasa ang istraktura. Ang Compact JSON ay ang tamang format para sa paghahatid: pinapaliit nito ang mga byte sa wire at storage. Ang naka-format na JSON ay ang tamang format para sa inspeksyon: ang naka-indent na hierarchy ay nagpapakita ng nested na istraktura sa isang sulyap, ginagawang makabuluhan ang mga pagkakaiba, at hinahayaan ang mga developer na mahanap ang mga partikular na field nang hindi na-parse ang dokumento sa isip.
Pina-parse ng formatter na ito ang input bilang JSON upang kumpirmahin na ito ay wasto, pagkatapos ay muling inilalabas ito nang may pare-parehong indentation. Ang di-wastong input ay nagdudulot ng error na tumuturo sa problema sa syntax. Ang wastong input ay na-reformat kahit gaano pa ka compact o kagulo ang pinagmulan. Nagde-default ang indentation sa dalawang espasyo, na tumutugma sa pinakakaraniwang JavaScript convention.
Nag-aalok din ang formatter ng minification (ang kabaligtaran na operasyon), na tinatanggal ang lahat ng hindi kinakailangang whitespace upang makagawa ng pinakamaliit na wastong JSON. Ang pinaliit na output ay kapaki-pakinabang para sa paghahatid ng produksyon; ang naka-format na output ay kapaki-pakinabang para sa pagbuo at pag-debug.
Bakit I-format ang JSON
Ang pagbabasa ng malalim na nested JSON nang walang indentation ay mahalagang imposible - ang istraktura ay teknikal na naroroon ngunit hindi nakikita. Kahit na ang katamtamang kumplikadong JSON ay nakikinabang nang husto mula sa pag-format. Ang mga tagasuri ng code, mga debugger ng API, at sinumang sumusubok na maunawaan ang isang payload ng data ay kailangang naka-format na JSON upang makita kung ano talaga ang naroroon.
Ang pag-format ay nakakakuha din ng mga error. Kung nabigo ang JSON na mag-parse sa panahon ng pag-format, tinutukoy ng mensahe ng error ang eksaktong posisyon ng problema sa syntax — kadalasan ay nawawalang kuwit, hindi naka-quote na key, o naliligaw na trailing comma na hindi na-flag ng system na gumagawa. Ang formatter ay ang pinakasimpleng JSON validator na available.
Mga Detalye ng Teknikal
Gumagamit ang formatter ng JSON.parse at JSON.stringify, ang parehong pares sa bawat pagpapadala ng JavaScript runtime. Sinusunod ng pag-parse ang RFC 8259 (ang kasalukuyang spec ng JSON), tinatanggap ang mahigpit na JSON ngunit tinatanggihan ang mga literal ng object ng JavaScript, komento, trailing na kuwit, at iba pang extension ng JSON5.
Tumatanggap ang JSON.stringify ng indent argument: isang numero (mga puwang) o string (custom na indent na character, gaya ng tab). Inilalantad ng formatter ang parehong mga opsyon. Ang output ay pinagbukud-bukod sa source order para sa mga bagay (dahil napanatili ng ES2015 ang pagkakasunod-sunod ng paglalagay ng property sa lahat ng pangunahing engine).
Edge cases: malalaking numero na lampas sa Number.MAX_SAFE_INTEGER ang nawawalan ng katumpakan kapag na-parse (isang kilalang limitasyon ng JSON; gumamit ng mga string value para sa mga ID na lampas sa 2^53). Ang mga Unicode escape sa mga string ay literal na pinapanatili. Ang sumusunod na whitespace ay tinanggal mula sa bawat linya.
Mga madalas itanong
- Anong mga uri ng mga error sa JSON ang nakikita ng tool na ito?
- Nakikita ng tool ang mga nawawalang kuwit, hindi magkatugmang mga bracket/braces, hindi wastong pag-eskapo ng string, mga trailing na kuwit, mga single-quoted na string, at iba pang mga paglabag sa syntax ayon sa detalye ng RFC 8259 JSON.
- Mahawakan ba nito ang napakalaking JSON file?
- Oo. Pinoproseso ng formatter ang JSON sa iyong browser gamit ang native na pag-parse ng JavaScript, kaya mahusay nitong pinangangasiwaan ang mga file hanggang sa ilang megabytes. Para sa napakalaking file (50MB+), ang oras ng pagproseso ay nakasalalay sa iyong device.
- Sinusuportahan ba nito ang JSON na may mga komento (JSONC)?
- Hindi pinapayagan ng karaniwang JSON ang mga komento. Kung ang iyong input ay naglalaman ng mga komento, ang validator ay i-flag ang mga ito bilang mga error. Para sa suporta ng JSONC, alisin ang mga komento bago mag-format.
- Mababago ba ng pag-format ang aking mga halaga ng data?
- Hindi. Ang pag-format ay nagsasaayos lamang ng whitespace at indentation — ang iyong mga uri ng data, mga halaga, at istraktura ay nananatiling eksaktong pareho.
- Sinusuportahan ba ang mga feature ng JSON5 (mga komento, trailing comma)?
- Hindi. Ang formatter ay mahigpit na sumusunod sa RFC 8259. Ang mga feature ng JSON5 ay nagdudulot ng mga error sa pag-parse. Upang gumana sa JSON5, i-convert muna sa karaniwang JSON gamit ang isang JSON5 parser.
- Na-upload ba ang aking JSON sa isang server?
- Hindi. Ang pag-parse at pag-format ay ganap na nangyayari sa iyong browser gamit ang mga built-in na JSON function.
- Mawawalan ba ng katumpakan ang malalaking numero?
- Ang JavaScript ay kumakatawan sa mga numero bilang 64-bit na mga float, kaya ang mga integer na higit sa 2^53 (mga 9 quadrillion) ay nawawalan ng katumpakan. Para sa mga ID o iba pang malalaking halaga ng integer, i-store ang mga ito bilang mga string sa JSON.
- Maaari ko bang ayusin ang mga susi ayon sa alpabeto?
- Ang JSON.stringify ay hindi nag-uuri ng mga key. Gumamit ng hiwalay na hakbang sa pag-uuri (o isang formatter na may suporta sa pag-uuri) upang i-alpabeto ang mga key bago mag-stringify.