సాధారణ JSON లోపాలు: చివరి కామా, కోట్స్, Unexpected token

మీ JSON చెల్లదని గుర్తు పెట్టబడింది. సాధారణంగా చిన్న వ్యాకరణ సమస్య, పాడైన ఫైల్ ఫార్మాట్ కాదు. కింది ఏడు తప్పులు చాలా Unexpected token కలిగిస్తాయి.

JSON ఎందుకు ఇంత సులభంగా పాడవుతుంది?

JSON కఠిన వ్యాకరణంతో డేటా ఫార్మాట్. JavaScript ఆబ్జెక్ట్ లిటరల్ ఒకేలా కనిపించి కూడా చెల్లని JSON కావచ్చు. ప్రామాణిక JSONలో ప్రాపర్టీ పేర్లు, స్ట్రింగ్‌లకు డబుల్ కోట్స్ కావాలి, చివరి కామా అనుమతి లేదు, వ్యాఖ్యలు ఫార్మాట్‌లో భాగం కావు.

1. చివరి కామాలు

చివరి ప్రాపర్టీ తర్వాత అదనపు కామా సమస్య. ప్రామాణిక JSON దాన్ని అనుమతించదు.

చెల్లదు

{
  "name": "Alex",
  "age": 30,
}

చెల్లుతుంది

{
  "name": "Alex",
  "age": 30
}

అదే నియమం అర్రేలకు. చివరి అంశం తర్వాత కామా తీసేయండి.

చెల్లదు

[
  "red",
  "green",
]

చెల్లుతుంది

[
  "red",
  "green"
]

2. డబుల్ బదులు సింగిల్ కోట్స్

JavaScript తరచు సింగిల్ కోట్స్ అంగీకరిస్తుంది. JSON కాదు. ప్రాపర్టీ పేర్లు, స్ట్రింగ్ విలువలు డబుల్ కోట్స్ వాడాలి.

చెల్లదు

{
  'name': 'Alex'
}

చెల్లుతుంది

{
  "name": "Alex"
}

3. కోట్ లేని ప్రాపర్టీ పేర్లు

JavaScriptలో కొన్నిసార్లు nameను కోట్ లేకుండా రాయవచ్చు. JSONలో ప్రతి ప్రాపర్టీ పేరు డబుల్-కోట్ స్ట్రింగ్ కావాలి.

చెల్లదు

{
  name: "Alex",
  age: 30
}

చెల్లుతుంది

{
  "name": "Alex",
  "age": 30
}

4. విలువల మధ్య లేని కామా

ప్రాపర్టీలు, అర్రే అంశాల మధ్య కామా కావాలి. పార్సర్ తర్వాతి కోట్ లేదా బ్రేస్‌పై Unexpected token చెప్పవచ్చు, లేని కామాపై కాదు.

చెల్లదు

{
  "name": "Alex"
  "age": 30
}

చెల్లుతుంది

{
  "name": "Alex",
  "age": 30
}

5. తక్కువ లేదా ఎక్కువ బ్రాకెట్లు

ఆబ్జెక్ట్‌లు { } వాడతాయి. అర్రేలు [ ]. నెస్టెడ్ JSON తరచు విఫలమవుతుంది: ] లేదు, } ఎక్కువ, లేదా రెండూ మారితే. తెరచి మూసే జతలను లెక్కించండి.

చెల్లదు

{
  "items": [1, 2
}

చెల్లుతుంది

{
  "items": [1, 2]
}

6. చెల్లని ఎస్కేప్ సీక్వెన్స్‌లు

JSON స్ట్రింగ్‌లో బ్యాక్‌స్లాష్ ఎస్కేప్ మొదలుపెడుతుంది. " , \ మరియు \n వంటివి చెల్లుతాయి. C:\Usersగా రాసిన Windows మార్గం కాదు: \U చట్టబద్ధ JSON ఎస్కేప్ కాదు. బ్యాక్‌స్లాష్‌లను రెట్టింపు చేయండి, లేకపోతే పార్సర్ ఆ అక్షరంపై ఆగుతుంది.

చెల్లదు

{"file":"C:\Users\Alex"}

చెల్లుతుంది

{"file":"C:\\Users\\Alex"}

7. JSON లోపల వ్యాఖ్యలు

ప్రామాణిక JSONలో వ్యాఖ్యలు లేవు. కొన్ని కాన్ఫిగ్ టూల్స్ // లేదా /* */ అంగీకరిస్తాయి (JSONC, JSON5 మొదలైనవి). అది ప్రామాణిక JSON కాదు, JSON.parse తిరస్కరిస్తుంది.

చెల్లదు

{
  // user name
  "name": "Alex"
}

Unexpected token అంటే ఏమిటి?

పార్సర్ ఆ స్థానంలో అనుమతి లేని అక్షరాన్ని కలిసింది. నివేదించిన చోటు చదవడం ఆగిన చోటు. ముందు కామా వదిలేస్తే, లోపం తర్వాతి ప్రాపర్టీ కోట్‌ను చూపవచ్చు. పదాలు రన్‌టైమ్‌పై మారతాయి; ప్రతి బ్రౌజర్ అదే వాక్యం ముద్రిస్తుందని ఆశించవద్దు.

Unexpected end of JSON input అంటే ఏమిటి?

విలువ పూర్తయ్యే ముందు టెక్స్ట్ అయిపోయింది. సాధారణ కారణాలు: } లేదా ] లేదు, కోసిన ఇన్‌పుట్, ఖాళీ బాడీ, లేదా తెగిన API స్పందన. ఒక్క బగ్ కాదు.

JSON.parse() ఎందుకు విఫలమవుతుంది?

JSON.parse() చెల్లు JSON టెక్స్ట్ మాత్రమే తీసుకుంటుంది. ఇది విజయం:

const text = '{"name":"Alex"}';
const data = JSON.parse(text);

ఇది విఫలం, ఎందుకంటే సింగిల్ కోట్స్ JSON కావు:

const text = "{'name':'Alex'}";
JSON.parse(text);

ఖచ్చితమైన లోప సందేశం JavaScript రన్‌టైమ్‌పై ఆధారపడి ఉంటుంది. సందేశాన్ని సూచనగా తీసుకుని, ఆ స్థానం దగ్గర కామాలు, కోట్స్, బ్రాకెట్లు చూడండి.

• JSON టెక్స్ట్
• ↓
• పార్సర్ టోకెన్‌లు చదువుతుంది
• ↓
• చెల్లు డేటా లేదా Unexpected token

JSON లోపాన్ని త్వరగా ఎలా కనుగొనాలి

ఈ క్రమంలో చేయండి. మొత్తం ఫైల్ తిరిగి రాసి మొదలుపెట్టవద్దు.

1. JSONను వాలిడేటర్ గుండా నడపండి.
2. మొదట నివేదించిన లోపం చదవండి.
3. నివేదించిన స్థానానికి కొంచెం ముందు చూడండి.
4. కామాలు చూడండి, ముఖ్యంగా చివరి మరియు లేనివి.
5. కోట్స్ చూడండి: డబుల్ మాత్రమే.
6. { } మరియు [ ] జత చేయండి.
7. స్ట్రింగ్‌లలో బ్యాక్‌స్లాష్ ఎస్కేప్ చూడండి.
8. కఠిన JSON కావాలంటే వ్యాఖ్యలు తీసేయండి.

సాధారణ సరిదిద్దుల త్వరిత పటం:

సమస్య	సరిదిద్దు
చివరి కామా	చివరి అంశం తర్వాత కామా తొలగించండి.
సింగిల్ కోట్స్	పేర్లు, స్ట్రింగ్‌లకు డబుల్ కోట్స్ వాడండి.
కోట్ లేని కీ	ప్రాపర్టీ పేరును డబుల్ కోట్స్‌లో చుట్టండి.
లేని కామా	ప్రాపర్టీలు లేదా అర్రే అంశాల మధ్య కామా పెట్టండి.
లేని బ్రాకెట్	ప్రతి { } మరియు [ ] జత మూయండి.
చెల్లని ఎస్కేప్	చట్టబద్ధ ఎస్కేప్ వాడండి, లేదా మార్గాల్లో బ్యాక్‌స్లాష్ రెట్టింపు చేయండి.
వ్యాఖ్య	ప్రామాణిక JSONకు // మరియు /* */ తీసేయండి.

బ్రౌజర్‌లో JSON ధృవీకరించి ఫార్మాట్ చేయండి

NEXNARA JSON ఫార్మాట్ / Diff ఈ పరికరంపై JSON తనిఖీ చేయగలదు.

ధృవీకరించవచ్చు, 2 స్పేస్, 4 స్పేస్ లేదా ట్యాబ్‌తో అందంగా చేయవచ్చు, minify, రెండు పత్రాలు పోల్చవచ్చు (JSON Diff), .json ఫైల్ తెరవవచ్చు. పార్సింగ్ బ్రౌజర్‌లో JSON.parse వాడుతుంది, eval కాదు.

5 MB కంటే పెద్ద పత్రాలు నెమ్మదిగా అనిపించవచ్చు. 15 MB కంటే పెద్ద టెక్స్ట్ బ్రౌజర్‌లో ప్రాసెస్ కాదు, పేజీ స్పందించేలా.

JSON ప్రాసెసింగ్ మీ బ్రౌజర్‌లోనే జరుగుతుంది. ఈ సాధనం కోసం టెక్స్ట్ NEXNARA సర్వర్‌కు పంపబడదు. ప్రకటనలు, ఇతర సైట్ లక్షణాలు ఇంకా నెట్‌వర్క్ వాడతాయి; అది ప్రాసెసింగ్ నుండి వేరు.

చెల్లని JSON తనిఖీ చేయాలా? JSON ఫార్మాట్ / Diff తెరిచి టెక్స్ట్ అతికించండి.

FAQ

నా JSON Unexpected token ఎందుకు అంటుంది?

పార్సర్ అక్కడ అనుమతి లేని అక్షరాన్ని కలిసింది. అసలు తప్పు—తరచు లేని కామా లేదా సింగిల్ కోట్—ఆ స్థానానికి కొంచెం ముందు ఉండవచ్చు.

JSONలో చివరి కామా అనుమతించబడుతుందా?

కాదు. ప్రామాణిక JSON చివరి ప్రాపర్టీ లేదా అర్రే అంశం తర్వాత కామా అనుమతించదు. JavaScript ఆబ్జెక్ట్ లిటరల్స్ తరచు అనుమతిస్తాయి.

JSON సింగిల్ కోట్స్ వాడవచ్చా?

కాదు. ప్రాపర్టీ పేర్లు, స్ట్రింగ్‌లు డబుల్ కోట్స్ వాడాలి.

JSONలో వ్యాఖ్యలు ఉండవచ్చా?

ప్రామాణిక JSONలో కాదు. కొన్ని టూల్స్ వ్యాఖ్యలతో JSONC లేదా JSON5 అంగీకరిస్తాయి; JSON.parse ఇంకా తిరస్కరిస్తుంది.

JSON.parse() ఎందుకు విఫలమవుతుంది?

స్ట్రింగ్ చెల్లు JSON కాదు. సాధారణ కారణాలు చివరి కామా, సింగిల్ కోట్స్, కోట్ లేని కీలు, వ్యాఖ్యలు, లేదా కోసిన విలువ. ఖచ్చితమైన సందేశం రన్‌టైమ్‌పై ఆధారపడి ఉంటుంది.

JSON చెల్లుతుందో ఎలా తనిఖీ చేయాలి?

JSON ఫార్మాట్ / Diff వంటి వాలిడేటర్‌లో అతికించండి, లేదా కన్సోల్‌లో JSON.parse పిలవండి. పార్సింగ్ విసిరితే టెక్స్ట్ చెల్లు JSON కాదు.