JSON.parse ఎందుకు "Unexpected token" అంటుంది?

ఇది JSON.parse Unexpected token పరిష్కారం: లోపం అర్థం, స్థానం ఎలా చదవాలి, బాడీ HTML అయితే ఏమి చేయాలి. చివరి కామా, కోట్స్, Unexpected end విస్తృత కవరేజ్ సాధారణ JSON లోపాలు: చివరి కామా, కోట్స్, Unexpected tokenలో ఉంది.

JSON.parse()లో “Unexpected token” అంటే ఏమిటి?

JSON.parse()కి JSON వ్యాకరణం కావాలి. ప్రస్తుత స్థానంలో చట్టవిరుద్ధ అక్షరం SyntaxError విసురుతుంది. {“name”:“Alex”,} చెల్లదు: ఆ కామా తర్వాత ఆబ్జెక్ట్ ముగియదు. సందేశ టెక్స్ట్ మరియు స్థానం రన్‌టైమ్‌పై ఇంకా మారతాయి.

JSON.parse() ఏ లోపం విసురుతుంది?

చెల్లని JSON సాధారణంగా SyntaxError విసురుతుంది. రకం నిర్ధారించడానికి error.name లాగ్ చేయండి. పూర్తి error.messageను హార్డ్‌కోడ్ చేయవద్దు: ఇంజిన్లు, వెర్షన్లు వేరే పదాలు వాడతాయి.

try {
  JSON.parse('{"name":"Alex",}');
} catch (error) {
  console.log(error.name);
  // SyntaxError
}

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

{‘name’:‘Alex’} చెల్లని JSON. {“name”:“Alex”} చెల్లుతుంది. JSON స్ట్రింగ్‌లు మరియు ఆబ్జెక్ట్ సభ్య పేర్లు డబుల్ కోట్స్ వాడతాయి. const user = { name: ‘Alex’ } వంటి JavaScript ఆబ్జెక్ట్ లిటరల్ చట్టబద్ధ JavaScript కావచ్చు, ఇంకా JSON టెక్స్ట్ కాదు.

చెల్లదు

{'name':'Alex'}

చెల్లుతుంది

{"name":"Alex"}

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

చివరి ప్రాపర్టీ లేదా అర్రే అంశం తర్వాత కామా చెల్లు ప్రామాణిక JSON కాదు. {“name”:“Alex”,“age”:30,} మరియు [1, 2, 3,] రెండూ విఫలం. దీన్ని Unexpected token కారణంగా చూడండి; సాధారణ JSON లోపాలు: చివరి కామా, కోట్స్, Unexpected token చివరి కామాలను లోతుగా కవర్ చేస్తుంది.

చెల్లదు

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

చెల్లుతుంది

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

[1, 2, 3,]

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

{ name: “Alex” } JavaScript ఆబ్జెక్ట్ లిటరల్ కావచ్చు. JSONలో సభ్య పేర్లు స్ట్రింగ్‌లు, డబుల్ కోట్స్ కావాలి: {“name”:“Alex”}.

చెల్లదు

{
  name: "Alex"
}

చెల్లుతుంది

{
  "name": "Alex"
}

4. చెల్లని స్ట్రింగ్ ఎస్కేప్

JSON టెక్స్ట్‌లో బ్యాక్‌స్లాష్ ఎస్కేప్ మొదలుపెడుతుంది. C:\Users\Alex వంటి ముడి మార్గం చెల్లదు ఎందుకంటే \U చట్టబద్ధ ఎస్కేప్ కాదు. బ్యాక్‌స్లాష్‌లను రెట్టింపు చేయండి. హోస్ట్-భాష స్ట్రింగ్ ఎస్కేప్‌ను JSON ఎస్కేప్‌తో కలపవద్దు. సాధారణ JSON లోపాలు: చివరి కామా, కోట్స్, Unexpected token దీన్ని లోతుగా కవర్ చేస్తుంది.

చెల్లదు

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

చెల్లుతుంది

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

5. JSON ముందు లేదా తర్వాత అదనపు టెక్స్ట్

JSON.parse ఒక JSON విలువను ఆశిస్తుంది. {“ok”:true} ముందు Success: వంటి ఉపసర్గ, లేదా తర్వాత done వంటి ప్రత్యయం, మొత్తం స్ట్రింగ్ చెల్లదు చేస్తుంది. ఒక JSON విలువ చుట్టూ అప్రధాన వైట్‌స్పేస్ అనుమతి. JSON విలువ ముందు లేదా తర్వాత స్పేస్ నిషేధం కాదు.

Success:
{"ok":true}

{"ok":true}
done

6. JSON బదులు HTML పార్స్ చేయడం

HTML పేజీపై response.json() పిలవడం సాధారణ Unexpected token కేసు. తప్పు endpointలు, 404 లేదా 500 HTML పేజీలు, లాగిన్ రీడైరెక్ట్‌లు, ప్రాక్సీ బాడీలు, ఫాల్‌బ్యాక్ పేజీలు తరచు మార్కప్‌తో మొదలవుతాయి. “Unexpected token < ఎల్లప్పుడూ HTML” చాలా బలమైనది: < సూచన, రుజువు కాదు.

fetch('/api/data')
  .then(response => response.json())

“Unexpected token <” సాధారణంగా ఏమి అర్థం?

JSON విలువలు సాధారణంగా <తో మొదలవవు. బాడీ లేదా తో మొదలైతే, < మొదటి చట్టవిరుద్ధ అక్షరం కావచ్చు. స్థానిక డీబగ్‌లో HTTP స్థితి, Content-Type, ముడి బాడీ చూడండి. ఇంజిన్ పదాలు ఇంకా మారతాయి.

పార్స్ చేసే ముందు స్పందన తనిఖీ చేయండి

fetch బాడీని ఒక్కసారి మాత్రమే వినియోగించవచ్చు. స్థానిక డీబగ్‌లో ముందు text() చదవండి, చిన్న ఉపసర్గ చూడండి, తర్వాత అదే స్ట్రింగ్‌ను JSON.parse చేయండి. అదే స్పందనపై response.json() తర్వాత response.text() పిలవవద్దు. సున్నితమైన ప్రొడక్షన్ పేలోడ్‌లను డిఫాల్ట్‌గా లాగ్ చేయవద్దు.

const response = await fetch(url);
const text = await response.text();

console.log(response.status);
console.log(response.headers.get("content-type"));
console.log(text.slice(0, 200));

try {
  const data = JSON.parse(text);
  console.log(data);
} catch (error) {
  console.error("Invalid JSON:", error);
}

“at position 123” అంటే ఏమిటి?

కొన్ని ఇంజిన్లు స్థానం, లైన్ లేదా నిలువు వరుస నివేదిస్తాయి. దగ్గర తప్పు కోట్, కామా, బ్రేస్ లేదా ఎస్కేప్ చూడండి. ఆ సూచిక పార్సింగ్ సమస్య గమనించిన చోటు; అసలు కారణం ముందు ఉండవచ్చు. అది ఖచ్చితమైన దోషపూరిత అక్షరమని హామీ లేదు.

Unexpected token vs Unexpected end

Unexpected token అంటే పార్సర్ ఆశించని అక్షరాన్ని కలిసింది. Unexpected end విలువ పూర్తయ్యే ముందు ఇన్‌పుట్ ఆగితే కనిపించవచ్చు, ఉదా. మూసే బ్రేస్ లేని {“name”:“Alex”. ఖచ్చితమైన పదాలు ఇంజిన్‌పై ఆధారపడి ఉంటాయి. సాధారణ JSON లోపాలు: చివరి కామా, కోట్స్, Unexpected token అసంపూర్ణ JSONను విస్తృతంగా కవర్ చేస్తుంది.

{"name":"Alex"

JSON JavaScript ఆబ్జెక్ట్ లిటరల్ కాదు

JSON డేటా ఫార్మాట్. JavaScript ఆబ్జెక్ట్ లిటరల్ JavaScript సింటాక్స్. కోట్ లేని కీలు, సింగిల్ కోట్స్, చివరి కామా ఉన్న JS ఆబ్జెక్ట్ చెల్లు JSON టెక్స్ట్ కాదు. JSON.parse JavaScript ఆబ్జెక్ట్ లిటరల్స్‌ను సురక్షితంగా పార్స్ చేయలేదు.

const data = {
  name: 'Alex',
  active: true,
};

{
  "name": "Alex",
  "active": true
}

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

ప్రామాణిక JSON వ్యాఖ్యలు మద్దతు ఇవ్వదు. ఆబ్జెక్ట్ లోపల // లైన్ చెల్లదు. JSON5 మరియు సారూప్య పొడిగింపులు వేరే ఫార్మాట్లు. JSON ఫార్మాట్ / Diff ప్రామాణిక JSONను JSON.parseతో ధృవీకరిస్తుంది, JSON5ను JSONగా చూడదు.

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

undefined, NaN, Infinity చెల్లు JSONనా?

కాదు. JSON విలువలు ఆబ్జెక్ట్, అర్రే, స్ట్రింగ్, సంఖ్య, true, false, null. undefined, NaN, Infinity కావు. టాప్-లెవెల్ విలువ ఆబ్జెక్ట్ లేదా అర్రే కావాల్సిన అవసరం లేదు: true, 123, “hello”, null చెల్లు JSON.

{"a":undefined}
{"a":NaN}
{"a":Infinity}

true
123
"hello"
null

Unexpected token లోపాన్ని దశలవారీగా ఎలా సరిచేయాలి

లోప స్ట్రింగ్‌పై కాదు, మూలంపై పని చేయండి:

1. ఇన్‌పుట్ నిజంగా JSONేనా నిర్ధారించండి—HTML, లాగ్‌లు లేదా JavaScript కాదు.
2. ముడి ఇన్‌పుట్ మొదటి అక్షరాలు చూడండి.
3. API నుండి వస్తే HTTP స్థితి మరియు Content-Type చూడండి. 200 కాదు, application/json కాదు చెల్లు JSONకు హామీ ఇవ్వవు.
4. సింటాక్స్‌ను JSON పార్సర్‌లో ధృవీకరించండి.
5. నివేదించిన స్థానం, లైన్ లేదా నిలువు వరుసను సూచనగా వాడండి, హామీ మూల కారణంగా కాదు.
6. ఆ ప్రాంతం దగ్గర కోట్స్, కామాలు, బ్రేస్‌లు, బ్రాకెట్లు, ఎస్కేప్‌లు చూడండి.
7. ఫార్మాట్ చేసిన, ధృవీకరించిన కాపీతో పోల్చండి.
8. సీరియలైజర్ లేదా endpoint సరిచేయండి. నివేదించిన టోకెన్‌ను యాదృచ్ఛికంగా తొలగించవద్దు.

JavaScriptలో JSON ఉత్పత్తి చేసేటప్పుడు JSON.stringify() వాడండి

చేతితో స్ట్రింగ్‌లు కలపడం కంటే JSON.stringify మంచిది. అది సీరియలైజ్ చేసే విలువలకు చెల్లు JSON టెక్స్ట్ ఇస్తుంది. ప్రతి JavaScript విలువ ఉండదు: undefined, ఫంక్షన్లు, సింబల్స్‌కు ప్రత్యేక ప్రవర్తన. ఆ వివరం ఇక్కడ పరిధి బయట.

const data = {
  name: "Alex",
  active: true
};
const json = JSON.stringify(data);
// {"name":"Alex","active":true}

చెల్లని JSON vs అసలు సరిదిద్దు

ఈ జతలు JSON.parseతో తనిఖీ అయ్యాయి. HTMLకు సరిదిద్దు స్పందన, సింటాక్స్ ఎడిట్ కాదు.

సమస్య	చెల్లదు	సరిదిద్దు
సింగిల్ కోట్స్	{'a':1}	{"a":1}
చివరి కామా	{"a":1,}	{"a":1}
కోట్ లేని కీ	{a:1}	{"a":1}
undefined	{"a":undefined}	{"a":null}
HTML బాడీ	<html>...	endpoint మరియు ముడి స్పందన చూడండి. HTMLను ఎడిట్ చేసి JSON చేయవద్దు.

సరళ Unexpected token నిర్ణయ మార్గదర్శి

JSON.parse విఫలమైతే, కోట్స్ తిరిగి రాసే ముందు మీ దగ్గర JSON ఉందా నిర్ణయించండి.

• JSON.parse విఫలం
• ↓
• API నుందా? స్థితి, Content-Type, ముడి బాడీ చూడండి
• JSONతో మొదలవుతుందా? కాకపోతే మూలం లేదా endpoint సరిచేయండి
• అవును అయితే కోట్స్, కామాలు, బ్రేస్‌లు, బ్రాకెట్లు, ఎస్కేప్‌లు, మద్దతు లేని విలువలు ధృవీకరించండి
• నివేదించిన స్థానాన్ని సూచనగా వాడండి
• ↓
• మూలం సరిచేసి మళ్లీ పార్స్ చేయండి

పార్స్ లేదా వాడే ముందు JSON ధృవీకరించండి

NEXNARA JSON ఫార్మాట్ / Diff బ్రౌజర్‌లో JSONను JSON.parseతో ధృవీకరిస్తుంది—eval కాదు.

ధృవీకరించవచ్చు, 2 స్పేస్, 4 స్పేస్ లేదా ట్యాబ్‌తో అందంగా చేయవచ్చు, minify, కాపీ, డౌన్‌లోడ్, .json అప్‌లోడ్. JSON Diff నెస్టెడ్ ఆబ్జెక్ట్‌లు మరియు అర్రేలు, మార్గాలు, సారాంశం, ఫిల్టర్లు, స్వాప్ కవర్ చేస్తుంది. పార్స్ తర్వాత అదే డేటా యొక్క ప్రిటీ మరియు minify కాపీలు సమానంగా పోల్చబడతాయి; ఆబ్జెక్ట్ కీలు పేరుతో పోల్చబడతాయి.

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

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

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

FAQ

JSON.parse ఎందుకు Unexpected token అంటుంది?

పార్సర్ ఆగిన స్థానంలో టెక్స్ట్ చెల్లు JSON కాదు. సాధారణ కారణాలు కోట్స్, కామాలు, అదనపు టెక్స్ట్, లేదా HTML వంటి JSON కాని బాడీ.

JSONలో Unexpected token < అంటే ఏమిటి?

మొదటి చట్టవిరుద్ధ అక్షరం < కావచ్చు. అది తరచు HTML పేజీని సూచిస్తుంది, కానీ ప్రతి కేసులో 404 లేదా HTML రుజువు కాదు. స్థితి, Content-Type, ముడి బాడీ చూడండి.

JSONలో లోప స్థానం ఎలా కనుగొనాలి?

ఇంజిన్ స్థానం, లైన్ లేదా నిలువు వరుస నివేదిస్తే దగ్గర చూడండి. అసలు తప్పు ముందు ఉండవచ్చు. సూచనగా వాడి ధృవీకరించండి.

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

కాదు. ప్రామాణిక JSON స్ట్రింగ్‌లు మరియు సభ్య పేర్లు డబుల్ కోట్స్ వాడతాయి.

JSONలో చివరి కామా ఉండవచ్చా?

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

స్ట్రింగ్ చెల్లు JSONనా ఎలా తనిఖీ చేయాలి?

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