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 વિરુદ્ધ 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 વિરુદ્ધ અસલ સુધારો

આ જોડાં 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 નથી.