JSON formatētājs: Skaisti noformēt un pārbaudīt JSON tiešsaistē bez maksas

Q: Kāda ir atšķirība starp JSON.parse() un JSON.stringify()?

JSON.parse() pārvērš JSON virkni par JavaScript vērtību. JSON.stringify() veic pretējo — pārvērš JavaScript vērtību par JSON virkni — un pieņem atkāpes argumentu formatētai izvadei. Šis rīks iekšēji neizmanto nevienu no šīm funkcijām, tāpēc tas var precīzi saglabāt lielus veselus skaitļus.

Kas ir JSON formatētājs?

JSON formatētājs ir rīks, kas pārveido JSON (JavaScript objektu notācijas) tekstu, pievienojot atkāpes un rindu pārtraukumus, nemainot pašus datus. JSON ir vienkārša teksta formāts strukturētu datu glabāšanai un nosūtīšanai, kas veidots no nosaukuma un vērtības pāriem, kā arī sarakstiem. Programmas parasti taupa vietu, noņemot visas liekās atstarpes, tādējādi izveidojot vienu blīvu rindu, ko cilvēkam ir grūti izlasīt. Formatētājs, ko sauc arī par skaistinātāju vai glīti formatētas izvades veidotāju, konsekventi pievieno šīs atstarpes atpakaļ, lai struktūra būtu redzama. Šis rīks JSON formatē automātiski, tiklīdz teksts tiek ievadīts vai ielīmēts. Formatēšanas pogas nav; izvade tiek atjaunināta pēc katra taustiņa nospiediena. Atiestatīšanas poga notīra ievadi, bet kopēšanas poga nokopē formatēto rezultātu.

JSON sintakses noteikumi

JSON definē specifikācija RFC 8259. Tai ir divu veidu konteineri:

Objekti satur nosaukuma un vērtības pārus figūriekavās:

1{"name": "John", "age": 30, "city": "New York"}
2

Masīvi satur sakārtotus sarakstus kvadrātiekavās:

1["apple", "banana", "cherry"]
2

JSON vērtībai jābūt vienam no sešiem tipiem: virknei, skaitlim, Būla vērtībai (true vai false), null, objektam vai masīvam.

Daži noteikumi izraisa lielāko daļu kļūdu:

Īpašību nosaukumiem jābūt ietvertiem dubultajās pēdiņās. {name: "John"} nav derīgs; jāizmanto {"name": "John"}.
Virknēm jāizmanto dubultās, nevis vienkāršās pēdiņas.
Aiz pēdējā elementa objektā vai masīvā nedrīkst būt komats (beigu komati nav atļauti).
JSON nav komentāru sintakses, lai gan tā figūriekavu un kvadrātiekavu izskats ir pārņemts no JavaScript.
JSON nav undefined. Trūkstošai vērtībai izmantojiet null.

Bieža kļūda ir JavaScript objekta literāļa ielīmēšana JSON vietā. {name: 'John', age: undefined} ir derīgs JavaScript, bet nav derīgs JSON. JSON versija ir {"name": "John", "age": null}.

Kā darbojas šis JSON formatētājs

Daudzi JSON formatētāji tekstu apstrādā ar JSON.parse(), lai izveidotu JavaScript objektu, un pēc tam izmanto JSON.stringify(), lai to ar atstarpēm pārveidotu atpakaļ tekstā. Šim turp-atpakaļ procesam ir blakusefekts: JavaScript skaitļi ir IEEE 754 dubultas precizitātes peldošā komata skaitļi, kas nespēj precīzi attēlot katru veselo skaitli, kad tas pārsniedz 2^53 − 1 (9,007,199,254,740,991). Identifikators, piemēram, 9007199254740993, pēc šāda procesa var tikt izvadīts kā 9007199254740992.

Šis rīks šo darbību neveic. Tas nolasa ievadi pa vienai rakstzīmei, izmantojot nelielu ar roku uzrakstītu analizatoru, un tā vietā, lai katru skaitli vai virkni pārveidotu par JavaScript vērtību, nokopē šo teksta daļu tieši tā, kā tā uzrakstīta, un pēc tam novieto to pareizajā atkāpes līmenī. Tā kā skaitļi nekad netiek pārveidoti par peldošā komata skaitļiem, jebkura lieluma veseli skaitļi saglabā precīzus ciparus. Ja objektā viena un tā pati atslēga ir uzrakstīta divreiz, abas kopijas tiek saglabātas savās vietās, nevis apvienotas ar pēdējo, kā tas notiktu, veidojot JavaScript objektu.

Process pa soļiem:

Nolasa nākamo marķieri (objektu, masīvu, virkni, skaitli, true, false vai null).
Pārbauda to atbilstoši JSON gramatikai. Ja marķieris pārkāpj kādu noteikumu, piemēram, ja atslēga nav pēdiņās vai ir beigu komats, tas tiek noraidīts.
Nokopē marķiera tekstu izvades laukā bez izmaiņām.
Pievieno rindu pārtraukumu un atkāpi ar 2 atstarpēm katram ligzdošanas līmenim objektā vai masīvā. Tukšs objekts vai masīvs paliek vienā rindā: {} vai [].
Atkārto, līdz visa ievade ir nolasīta.

Atkāpe ir fiksēta — 2 atstarpes; iestatījuma tās mainīšanai nav. Kamēr ievades lauks ir tukšs, izvades panelī tiek rādīts viettura teksts “Formatēts JSON šeit parādīsies automātiski...”. Ja ievade pārkāpj JSON noteikumu, rīks tehniska sintakses analizatora kļūdas ziņojuma ar precīzu rakstzīmes pozīciju vietā parāda ziņojumu “Nederīgs JSON: pārbaudiet ievadi”. Turpretī pārlūkprogrammu iebūvētais JSON.parse() kļūdas tekstā norāda rakstzīmes pozīciju.

Aprēķina piemērs

Šī minificētā ievade:

1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2

kļūst par:

1{
2  "name": "John Doe",
3  "age": 30,
4  "address": {
5    "street": "123 Main St",
6    "city": "Anytown",
7    "state": "CA"
8  },
9  "hobbies": [
10    "reading",
11    "hiking",
12    "photography"
13  ]
14}
15

Katrs ligzdotais objekts vai masīvs tiek ievilkts par vienu līmeni vairāk nekā tā vecākelements, tāpēc saistība starp address un tā trim laukiem ir redzama uzreiz.

Otrs piemērs parāda, kāpēc ir svarīgi kopēt literāļus. Šī ievade:

1{"id":9007199254740993}
2

tiek formatēta šādi:

1{
2  "id": 9007199254740993
3}
4

Cipari paliek tieši tādi, kā ievadīti. Formatētājs, kas izmanto JSON.parse() un pēc tam JSON.stringify(), tā vietā šo skaitli nemanāmi pārvērstu par 9007199254740992.

Biežākās JSON kļūdas

Īpašības nosaukums bez pēdiņām: {name: "John"}. Labojums: {"name": "John"}.
Beigu komats: {"age": 30,}. Labojums: noņemiet komatu pirms noslēdzošās figūriekavas.
Nesakritīgas iekavas: {"data": [1, 2}. Labojums: pirms objekta aizvēršanas aizveriet masīvu ar ].
Neaizvērta virkne: {"name": "John}. Labojums: pievienojiet trūkstošo noslēdzošo pēdiņu.
Vienkāršās pēdiņas: {'name': 'John'}. Labojums: izmantojiet dubultās pēdiņas.
undefined, NaN vai Infinity: neviena no šīm vērtībām nav derīga JSON vērtība. Izmantojiet null vai virkni.

Biežs šo kļūdu avots ir objekta tieša kopēšana no pārlūkprogrammas konsoles vai servera žurnāla, kuros bieži ir tikai JavaScript raksturīga sintakse, kas jāiztīra, pirms objekts kļūst par derīgu JSON.

Kad izmantot JSON formatētāju

JSON formatētājus visbiežāk izmanto API atbilžu pārbaudei, jo tās parasti tiek nosūtītas minificētā veidā, lai taupītu joslas platumu. Tos izmanto arī konfigurācijas failu, piemēram, package.json vai composer.json, manuālai pārbaudei, datu nolasīšanai, kas nokopēti no pārlūkprogrammas lokālās krātuves vai konsoles, kā arī no citas sistēmas saņemtas datu kopas struktūras izpratnei.

Citi JSON formatēšanas veidi

Pārlūkprogrammu izstrādātāju rīki: Chrome, Edge un Firefox automātiski formatē JSON atbildes cilnes Network priekšskatījuma panelī.
Koda redaktori: Visual Studio Code atvērtu JSON failu formatē ar Alt+Shift+F (Mac datorā — Shift+Option+F). Lielākajai daļai redaktoru ir līdzīga īsinājumtaustiņu kombinācija vai formatēšanas paplašinājums.
Komandrinda: jq (jq . file.json) un Python iebūvētais rīks python -m json.tool file.json abi formatē JSON terminālī.

JSON formatēšanas ieviešana kodā

Lielākajā daļā programmēšanas valodu ir JSON bibliotēka ar atkāpju opciju. JavaScript:

1const formatted = JSON.stringify(JSON.parse(rawJson), null, 2);
2

Python:

1import json
2formatted = json.dumps(json.loads(raw_json), indent=2)
3

Abas pieejas analizē tekstu un izveido vietējo datu struktūru, pēc tam to atkārtoti serializē ar atstarpēm. To ir vienkārši uzrakstīt, taču tā var mainīt skaitļus. JavaScript katru skaitli glabā kā dubultas precizitātes skaitli, tāpēc 9007199254740993 tiek atgriezts kā 9007199254740992. Python saglabā veselus skaitļus precīzus, jo Python veseliem skaitļiem nav lieluma ierobežojuma, taču tas joprojām pārraksta 1.0e2 kā 100.0 un pārvērš 1e999 par Infinity, kas nav derīgs JSON. Lietotnes, kurām vajadzīgi precīzi lieli veseli skaitļi, piemēram, datubāzu identifikatori, bieži tos JSON formātā glabā kā virknes, nevis skaitļus.

Īsa JSON vēsture

Douglas Crockford JSON specifikāciju izstrādāja 2000. gadu sākumā, pārņemot sintaksi no JavaScript objektu literāļiem, bet padarot to izmantojamu jebkurā valodā. RFC 4627 to formalizēja 2006. gadā. JSON ātri izplatījās, jo to bija īsāk rakstīt nekā XML un tas tieši atbilda JavaScript objektiem; tas bija nozīmīgi, kad tīmekļa lietotnes sāka fonā iegūt datus, nevis atkārtoti ielādēt visas lapas. 2010. gados tas bija kļuvis par noklusējuma formātu REST API un tādām datubāzēm kā MongoDB.

Biežāk uzdotie jautājumi

Kas ir JSON formatētājs? Rīks, kas JSON tekstam pievieno atkāpes, rindu pārtraukumus un atstarpes, lai tā struktūru būtu viegli izlasīt, nemainot datus.

Vai formatēšana maina datus? Nē. Formatēšana maina tikai atstarpes. Šis rīks katru virkni un skaitli nokopē tieši tā, kā tas ievadīts, tāpēc formatētās izvades vērtības precīzi atbilst ievadei, tostarp skaitļi, kas ir pārāk lieli, lai tos precīzi glabātu kā JavaScript skaitli.

Kāpēc tiek parādīta kļūda “Nederīgs JSON”? Ievade pārkāpj JSON noteikumu. Biežākie iemesli ir īpašības nosaukumi bez pēdiņām, beigu komats, vienkāršās pēdiņas, neaizvērta virkne vai nesakritīgas iekavas. Šis rīks neparāda precīzu problēmas rakstzīmes pozīciju; pārbaudot ievadi atbilstoši iepriekš minētajiem noteikumiem, problēmu parasti var ātri atrast.

Vai JSON var būt komentāri? Nē. Specifikācija tos neatļauj. Tādi formāti kā JSONC un JSON5 papildina JSON sintaksi ar komentāru atbalstu gadījumiem, kad tas ir noderīgi, piemēram, konfigurācijas failos.

Kāda ir standarta JSON atkāpe? Divas atstarpes ir visbiežāk izmantotā tīmekļa izstrādes konvencija, un to izmanto arī šis rīks. Dažās stila vadlīnijās tā vietā izmanto četras atstarpes vai tabulēšanas rakstzīmes; pati JSON specifikācija nepieprasa konkrētu atkāpi.

Kāda ir atšķirība starp JSON.parse() un JSON.stringify()? JSON.parse() pārvērš JSON virkni par JavaScript vērtību. JSON.stringify() veic pretējo — pārvērš JavaScript vērtību par JSON virkni — un pieņem atkāpes argumentu formatētai izvadei. Šis rīks iekšēji neizmanto nevienu no šīm funkcijām, tāpēc tas var precīzi saglabāt lielus veselus skaitļus.

JSON formatētājs: Skaisti noformēt un pārbaudīt JSON tiešsaistē bez maksas