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 അല്ല.