რატომ ამბობს 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.