Ինչու է JSON.parse-ը ասում «Unexpected token»։

Սա Unexpected token-ի ախտորոշում է JSON.parse-ում՝ ինչ է նշանակում սխալը, ինչպես կարդալ դիրքը և ինչ անել, երբ մարմինը HTML է։ Վերջի ստորակետը, չակերտները և Unexpected end-ը ավելի լայնորեն կան Հաճախակի JSON սխալներ՝ վերջի ստորակետ, չակերտներ և Unexpected token-ում։

Ի՞նչ է նշանակում “Unexpected token” JSON.parse()-ում։

JSON.parse()-ը պահանջում է JSON քերականություն։ Ընթացիկ դիրքի անօրինական նիշը նետում է SyntaxError։ {“name”:“Alex”,} անվավեր է․ այդ ստորակետից հետո օբյեկտը չի կարող ավարտվել։ Հաղորդագրության տեքստը և դիրքը դեռ տարբերվում են ըստ runtime-ի։

Ի՞նչ սխալ է նետում 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 տողերն ու օբյեկտի անդամի անուններն օգտագործում են կրկնակի չակերտներ։ JavaScript օբյեկտի լիտերալը, ինչպես const user = { name: ‘Alex’ }, կարող է լինել օրինական 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. Անվավեր տողի escape

JSON տեքստում հետշեղը սկսում է escape։ Հում ուղին, ինչպես C:\Users\Alex, անվավեր է, որովհետև \U օրինական escape չէ։ Կրկնապատկեք հետշեղերը։ Մի խառնեք հյուրընկալող լեզվի escape-ը JSON escape-ի հետ։ Հաճախակի JSON սխալներ՝ վերջի ստորակետ, չակերտներ և Unexpected token-ը սա ծածկում է ավելի խորությամբ։

Անվավեր

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

Վավեր

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

5. Ավել տեքստ JSON-ից առաջ կամ հետո

JSON.parse-ը սպասում է մեկ JSON արժեք։ Success: նախածանցը {“ok”:true}-ից առաջ, կամ done վերջածանցը հետո, ամբողջ տողը դարձնում է անվավեր։ Աննշան բացատը մեկ JSON արժեքի շուրջ թույլատրված է։ JSON-ը չի արգելում բացատներ արժեքից առաջ կամ հետո։

Success:
{"ok":true}

{"ok":true}
done

6. HTML-ի վերլուծում JSON-ի փոխարեն

response.json() կանչել HTML էջի վրա 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”։

Որոշ շարժիչներ հաղորդում են դիրք, տող կամ սյունակ։ Մոտակայքում փնտրեք սխալ չակերտ, ստորակետ, փակագիծ կամ escape։ Այդ ինդեքսը այն է, որտեղ վերլուծությունը նկատել է խնդիր․ իրական պատճառը կարող է ավելի վաղ լինել։ Երաշխավորված չէ, որ դա ճշգրիտ վնասված նիշն է։

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. Ստուգեք չակերտներ, ստորակետներ, փակագծեր, քառակուսի փակագծեր և escape-ներ այդ տարածքի մոտ։
7. Համեմատեք ձևաչափված, ստուգված պատճենի հետ։
8. Ուղղեք սերիալիզատորը կամ endpoint-ը։ Պատահական մի ջնջեք հաղորդված նշանը։

Օգտագործեք JSON.stringify() JavaScript-ում JSON արտադրելիս

Նախընտրեք 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-ը
• Եթե այո, ստուգեք չակերտներ, ստորակետներ, փակագծեր, քառակուսի փակագծեր, escape-ներ, չաջակցվող արժեքներ
• Օգտագործեք հաղորդված դիրքը որպես ակնարկ
• ↓
• Ուղղեք աղբյուրը, ապա նորից վերլուծեք

Ստուգեք 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 չէ այն կետում, որտեղ վերլուծիչը կանգնել է։ Տիպիկ պատճառներ՝ չակերտներ, ստորակետներ, ավել տեքստ կամ ոչ JSON մարմին, ինչպես HTML։

Ի՞նչ է նշանակում Unexpected token < in JSON։

Առաջին անօրինական նիշը կարող է լինել <։ Դա հաճախ մատնանշում է HTML էջ, բայց ամեն դեպքում 404-ի կամ HTML-ի ապացույց չէ։ Ստուգեք կարգավիճակը, Content-Type և հում մարմինը։

Ինչպե՞ս գտնել սխալի դիրքը JSON-ում։

Եթե շարժիչը հաղորդում է դիրք, տող կամ սյունակ, նայեք մոտակայքում։ Իրական սխալը կարող է ավելի վաղ լինել։ Օգտագործեք որպես ակնարկ, ապա ստուգեք։

Կարո՞ղ է JSON-ը օգտագործել մեկ չակերտ։

Ոչ։ Ստանդարտ JSON տողերն ու անդամի անուններն օգտագործում են կրկնակի չակերտներ։

Կարո՞ղ է JSON-ը ունենալ վերջի ստորակետներ։

Ոչ։ Ստանդարտ JSON-ը չի թույլատրում ստորակետ վերջին հատկությունից կամ զանգվածի տարրից հետո։

Ինչպե՞ս ստուգել, որ տողը վավեր JSON է։

Կանչեք JSON.parse try/catch-ում, կամ տեղադրեք տեքստը JSON ձևաչափում / Diff-ում։ Եթե վերլուծությունը նետում է SyntaxError, տողը վավեր JSON չէ։