როგორ გამოვასწოროთ არასწორი JSON: გავრცელებული შეცდომები და მაგალითები

JSON-თან დაკავშირებული შეცდომები შესაძლოა გამაღიზიანებელი იყოს, რადგან ერთმა პატარა სიმბოლომ შეიძლება შეაჩეროს მთლიანი ფაილის, API მოთხოვნის ან კონფიგურაციის დამუშავება (პარსვა).

სასიხარულოა, რომ არასწორი ფორმატის მქონე JSON-ის პრობლემები, როგორც წესი, რამდენიმე ტიპურ და ადვილად გამოსაცნობ შეცდომას უკავშირდება: გამოტოვებული მძიმეები, არასწორი ბრჭყალები, ზედმეტი მძიმეები (ბოლო ელემენტის შემდეგ), შეუსაბამო ფრჩხილები ან არასწორი „ესკეიპ-მიმდევრობები“ (escape sequences).

JSON-ის შეცდომების აღმოფხვრის ყველაზე სწრაფი გზაა მისი ჯერ ვალიდაცია (შემოწმება), შემდეგ სინტაქსური შეცდომის გასწორება და ბოლოს — ფორმატირება, რათა სტრუქტურა უფრო ადვილად აღსაქმელი გახდეს.

გამოიყენეთ Codelope-ის JSON Validator სინტაქსის შესამოწმებლად და JSON Formatter შეკუმშული ან არეული JSON-ის წაკითხვად, სწორად დაფორმატებულ (შესაბამისი დაშორებებით) სახეში გადასაყვანად.

არასწორი JSON-ის გასწორების სწრაფი გზა

მიჰყევით ამ ინსტრუქციას, როდესაც JSON-ის დამუშავება (პარსვა) ვერ ხერხდება:

1. ჩასვით JSON კოდი Codelope JSON Validator-ში.
2. შეამოწმეთ მითითებული შეცდომის ადგილმდებარეობა.
3. დაათვალიერეთ აღნიშნული და მასზე წინა სტრიქონი.
4. გამოასწორეთ სინტაქსური შეცდომა.
5. ხელახლა ჩაატარეთ JSON-ის ვალიდაცია.
6. მას შემდეგ, რაც კოდი ვალიდური გახდება, გახსენით ის Codelope JSON Formatter-ში, რათა ჩაშენებული ობიექტებისა და მასივების წაკითხვა გაგიადვილდეთ.

შეცდომები სათითაოდ გამოასწორეთ. ერთმა გამოტოვებულმა მძიმემ ან ბრჭყალმა შეიძლება გამოიწვიოს შემდგომი შეცდომების სერია, მაშინაც კი, თუ რეალური პრობლემა მხოლოდ ერთი იყო.

1. გამოტოვებული მძიმეები

ობიექტში შემავალი თვისებები (properties) და მასივში შემავალი ელემენტები ერთმანეთისგან მძიმეებით უნდა იყოს გამოყოფილი.

არასწორი JSON

{
"name": "Alice"
"email": "[email protected]"
}

"Alice"-ის შემდეგ მძიმე აკლია.

გასწორებული JSON

{
"name": "Alice",
"email": "[email protected]"
}

თუ პარსერი ახალი თვისების დასაწყისზე მიუთითებს, ჯერ წინა სტრიქონი შეამოწმეთ. რეალური შეცდომა ხშირად სწორედ იქ არის.

2. ზედმეტი მძიმეები (ბოლო ელემენტის შემდეგ)

სტანდარტული JSON არ უშვებს მძიმის გამოყენებას ბოლო თვისების ან მასივის ელემენტის შემდეგ. ### არასწორი JSON

{
"name": "Alice",
"age": 28,
}

გასწორებული JSON

{
"name": "Alice",
"age": 28
}

ეს გავრცელებული შეცდომაა JSON-ის ხელით წერისას, რადგან ზოგიერთი პროგრამირების ენა მსგავსი სტრუქტურის მქონე ობიექტებსა და მასივებში ბოლო ელემენტის შემდეგ მძიმის (trailing comma) გამოყენების საშუალებას იძლევა.

3. ორმაგი ბრჭყალების ნაცვლად — ერთმაგი ბრჭყალები

JSON-ში თვისებების სახელებისა და სტრიქონული მნიშვნელობებისთვის აუცილებელია ორმაგი ბრჭყალების გამოყენება.

არასწორი JSON

{
'name': 'Alice'
}

გასწორებული JSON

{
"name": "Alice"
}

ამ შეცდომის ხშირი მიზეზია კოდის კოპირება ისეთი ენებიდან, როგორიცაა Python-ი, ან ობიექტის სინტაქსის გადმოტანა JavaScript-იდან.

4. ბრჭყალების გარეშე მითითებული თვისებების სახელები

JSON-ობიექტში თვისების (property) თითოეული სახელი ბრჭყალებში ჩასმულ სტრიქონს უნდა წარმოადგენდეს.

არასწორი JSON

{
name: "Alice",
age: 28
}

გასწორებული JSON

{
"name": "Alice",
"age": 28
}

JavaScript-ის ობიექტის ლიტერალმა შეიძლება მიიღოს თვისებების სახელები ბრჭყალების გარეშე, მაგრამ სტანდარტული JSON ამას არ უშვებს.

5. არასწორად დასმული ფიგურული და კვადრატული ფრჩხილები

JSON-ობიექტებში გამოიყენება {} ფრჩხილები, ხოლო მასივებში — []. თითოეულ გამხსნელ სიმბოლოს უნდა ჰქონდეს შესაბამისი დამხურავი სიმბოლო.

არასწორი JSON

{
"user": {
"name": "Alice",
"roles": [
"admin",
"editor"
]
}

გარე ობიექტს აკლია დამხურავი } ფრჩხილი.

გასწორებული JSON

{
"user": {
"name": "Alice",
"roles": [
"admin",
"editor"
]
}
}

ჩაშენებული (nested) JSON-ის შემთხვევაში მსგავსი შეცდომის შემჩნევა შეიძლება რთული იყოს. მას შემდეგ, რაც JSON-ის პარსვა (დამუშავება) შესაძლებელი გახდება, JSON Formatter მნიშვნელოვნად აადვილებს ჩაშენებული სტრუქტურის შემოწმებას.

6. გამოტოვებული ორწერტილები

ორწერტილი უნდა ჰყოფდეს ობიექტის თითოეულ გასაღებს (key) მის მნიშვნელობასთან.

არასწორი JSON

{
"name" "Alice",
"age": 28
}

გასწორებული JSON

{
"name": "Alice",
"age": 28
}

თუ პარსერი მუშაობას წყვეტს თვისების სახელის შემდეგ, შეამოწმეთ, ხომ არ აკლია ორწერტილი.

7. სტრიქონში არსებული ბრჭყალები, რომლებიც არ არის ეკრანიზებული (unescaped)

JSON-ის სტრიქონში არსებული ორმაგი ბრჭყალები უნდა იყოს ეკრანიზებული (ანუ მათ წინ უნდა ეწეროს უკუდახრილი ხაზი — \).

არასწორი JSON

{
"message": "She said "hello" to me."
}

hello-მდე არსებული ბრჭყალი აღიქმება როგორც სტრიქონის დასასრული.

გასწორებული JSON

{
"message": "She said \"hello\" to me."
}

უკუდახრილი ხაზი (backslash) პარსერს აცნობებს, რომ შიდა ბრჭყალები ტექსტის ნაწილია. ## 8. არასწორი უკუდახრილი ხაზები (backslashes)

JSON-ის სტრიქონში უკუდახრილი ხაზი (\) იწყებს ე.წ. „ესკეიპ-მიმდევრობას“ (escape sequence). შესაბამისად, თუ თავად სიმბოლო „უკუდახრილი ხაზის“ გამოყენება გსურთ, ის უნდა იქნას ეკრანიზებული (escape).

არასწორი JSON

{
"path": "C:\new\test"
}

JSON-ის სტრიქონებში ისეთ მიმდევრობებს, როგორიცაა \n და \t, სპეციალური მნიშვნელობა აქვთ.

გასწორებული JSON

{
"path": "C:\\new\\test"
}

ეს პრობლემა ხშირად გვხვდება Windows-ის ფაილურ გზებთან, რეგულარულ გამოსახულებებთან (regex) და ხელით გენერირებულ JSON-თან მუშაობისას.

9. არასწორი ბულეური (boolean) და null მნიშვნელობები

JSON იყენებს შემდეგ პატარა ასოებით დაწერილ ლიტერალებს:

true
false
null

არასწორი JSON

{
"enabled": True,
"deleted": False,
"description": None
}

გასწორებული JSON

{
"enabled": true,
"deleted": false,
"description": null
}

True, False და None ნაცნობია Python-ისთვის, მაგრამ ისინი არ წარმოადგენს JSON-ის ვალიდურ ლიტერალებს.

10. კომენტარები JSON-ში

სტანდარტული JSON არ უჭერს მხარს კომენტარებს.

არასწორი JSON

{
"host": "example.com",
// Production port
"port": 443
}

გასწორებული JSON

{
"host": "example.com",
"port": 443
}

კონფიგურაციის ზოგიერთი ფორმატი JSON-ის მსგავსია და უჭერს მხარს კომენტარებს, თუმცა ეს არ ნიშნავს, რომ იგივე შინაარსი ვალიდურ სტანდარტულ JSON-ად ითვლება.

11. მრავალი უმაღლესი დონის (top-level) მნიშვნელობა

ჩვეულებრივი JSON დოკუმენტი შეიცავს მხოლოდ ერთ უმაღლესი დონის მნიშვნელობას.

არასწორი JSON

{"id": 1}
{"id": 2}

თუ ორივე ობიექტი ერთ JSON დოკუმენტს უნდა ეკუთვნოდეს, მოათავსეთ ისინი მასივში (array).

გასწორებული JSON

[
{
"id": 1
},
{
"id": 2
}
]

ზოგიერთი სისტემა მიზანმიმართულად იყენებს ახალი ხაზით გამიჯნულ JSON-ს (newline-delimited JSON), რომელსაც ასევე უწოდებენ NDJSON-ს ან JSON Lines-ს. ეს ცალკე ფორმატია და არ უნდა განიხილებოდეს როგორც ერთიანი სტანდარტული JSON დოკუმენტი. ## 12. სტრიქონული მნიშვნელობები ბრჭყალების გარეშე

ტექსტური მნიშვნელობები ორმაგ ბრჭყალებში უნდა იყოს მოქცეული.

არასწორი JSON

{
"status": active
}

გასწორებული JSON

{
"status": "active"
}

რიცხვები, ლოგიკური (boolean) მნიშვნელობები და null ბრჭყალების გარეშე უნდა დაიწეროს, როდესაც სწორედ ამ მონაცემთა ტიპების გამოყენება გსურთ.

მაგალითად:

{
"count": 42,
"enabled": true,
"result": null
}

13. რიცხვის არასწორი სინტაქსი

JSON-ში რიცხვების სინტაქსი უფრო მკაცრია, ვიდრე ზოგიერთ პროგრამირების ენაში.

მაგალითად, რიცხვის დასაწყისში პლუსის ნიშნის გამოყენება დაუშვებელია.

არასწორი JSON

{
"change": +5
}

გასწორებული JSON

{
"change": 5
}

ისეთი მნიშვნელობები, როგორიცაა NaN და Infinity, ასევე არ შედის სტანდარტულ JSON-ში.

თუ API-ს ან აპლიკაციას ამ მდგომარეობების წარმოდგენა სჭირდება, გამოიყენეთ შესაბამისი სისტემის მიერ განსაზღვრული ფორმატი.

14. სტრიქონებში სტრიქონის გადატანის სიმბოლოები

JSON-ის სტრიქონში (string) სტრიქონის გადატანის სიმბოლო (line break) პირდაპირ არ უნდა იყოს გამოყენებული.

არასწორი JSON

{
"message": "First line
Second line"
}

ამის ნაცვლად გამოიყენეთ სტრიქონის გადატანის მართვის სიმბოლო (escape sequence).

გასწორებული JSON

{
"message": "First line\nSecond line"
}

ეს ხშირად ხდება მაშინ, როდესაც ტექსტი ფორმებიდან, ჟურნალ-ფაილებიდან (logs), დოკუმენტებიდან ან ტექსტური ველებიდან ხელით შეგვაქვს JSON-ში.

როგორ წავიკითხოთ JSON-ის პარსერის შეცდომის შესახებ შეტყობინებები

პარსერის შეტყობინებები განსხვავდება ბრაუზერების, პროგრამირების ენების, API-ებისა და დეველოპერის ხელსაწყოების მიხედვით. ისინი ხშირად მიუთითებენ სტრიქონის, სვეტის, სიმბოლოს ან ბაიტის პოზიციას.

მაგალითად:

JSON.parse('{"name":"Alice",}');

ეს კოდი შეცდომას იწვევს, რადგან ობიექტი შეიცავს ზედმეტ მძიმეს ბოლო ელემენტის შემდეგ.

მითითებული პოზიცია ყოველთვის არ ემთხვევა ზუსტად იმ სიმბოლოს, სადაც შეცდომა დაიწყო. პარსერმა შესაძლოა განაგრძოს კითხვა მანამ, სანამ არ წააწყდება ისეთ ელემენტს (ტოკენს), რომელიც დაადასტურებს, რომ JSON არასწორია.

ეს ნიშნავს, რომ უნდა შეამოწმოთ ორივე:

• შეცდომის მითითებული პოზიცია
• მასზე წინ მდებარე ელემენტი (ტოკენი)

დიდი ზომის JSON მონაცემების შემთხვევაში, სიმბოლოებისა და სტრიქონების ხელით დათვლის ნაცვლად, ჩასვით შიგთავსი Codelope JSON Validator-ში.

მაგალითი: JSON-ის რამდენიმე შეცდომის ერთდროულად გასწორება

განვიხილოთ შემდეგი მონაცემები:

{
'name': 'Alice',
"active": True,
"roles": [
"admin",
"editor",
],
}

ის ოთხ პრობლემას შეიცავს:

1. თვისებისა და სტრიქონული მნიშვნელობისთვის გამოყენებულია ბრჭყალები (single quotes).
2. True არ არის JSON-ის სწორი ლოგიკური (boolean) მნიშვნელობა.
3. მასივს ბოლო ელემენტის შემდეგ ზედმეტი მძიმე აქვს.
4. გარე ობიექტს ბოლო ელემენტის შემდეგ ზედმეტი მძიმე აქვს.

გასწორებული ვერსია:

{
"name": "Alice",
"active": true,
"roles": [
"admin",
"editor"
]
}

ჩასვით გასწორებული ვერსია JSON Validator-ში, რათა დარწმუნდეთ, რომ მისი დამუშავება (პარსვა) წარმატებით ხდება.

JSON-ის ვალიდაცია და ფორმატირება

ვალიდაცია და ფორმატირება პრობლემის სხვადასხვა ასპექტს აგვარებს. JSON-ის ვალიდატორი ამოწმებს, შეესაბამება თუ არა ტექსტი JSON-ის სწორ სინტაქსს.

JSON-ის ფორმატერი სწორ JSON-ს ისე წარმოადგენს, რომ დაშორებებისა და სტრიქონების გადატანის მეშვეობით მისი სტრუქტურა უფრო ადვილად წასაკითხი ხდება.

მაგალითად, ეს არის სწორი JSON:

{"user":{"id":42,"name":"Alice","roles":["admin","editor"]},"active":true}

Codelope-ის JSON-ის ფორმატერი ამავე მონაცემების აღქმას აადვილებს:

{
"user": {
"id": 42,
"name": "Alice",
"roles": [
"admin",
"editor"
]
},
"active": true
}

მონაცემები არ შეცვლილა; განსხვავებულია მხოლოდ მათი ვიზუალური წარმოდგენა.

გამართვის (debugging) პრაქტიკული პროცესი ასეთია:

1. შეამოწმეთ JSON-ის სისწორე (ვალიდაცია).
2. გამოასწორეთ სინტაქსური შეცდომა.
3. ხელახლა შეამოწმეთ.
4. დააფორმატეთ გამართული JSON.
5. გადახედეთ სტრუქტურასა და მნიშვნელობებს.

გამართული JSON-იც კი შეიძლება არ იყოს შესაფერისი API-სთვის

JSON-ის სინტაქსური შემოწმების გავლა არ ნიშნავს, რომ API მონაცემებს მიიღებს.

ეს არის გამართული JSON:

{
"email": 12345,
"enabled": "banana"
}

მაგრამ API-მ შესაძლოა მოითხოვოს:

{
"email": "[email protected]",
"enabled": true
}

თუ JSON-ის ვალიდატორი ადასტურებს, რომ თქვენი დოკუმენტი გამართულია, მაგრამ API მას მაინც უარყოფს, შეამოწმეთ API-ს მოთხოვნები შემდეგ საკითხებზე:

• სავალდებულო ველები (properties)
• ველების სახელები
• მონაცემთა მოსალოდნელი ტიპები
• დასაშვები მნიშვნელობები
• ობიექტებისა და მასივების ბუდობა (nesting)
• მოთხოვნის ტანის (request body) სტრუქტურა

სინტაქსური ვალიდაცია პასუხობს კითხვას:

არის თუ არა ეს გამართული JSON?

API-ს სქემა (schema) პასუხობს კითხვას:

არის თუ არა ეს JSON-ის ის სტრუქტურა, რომელსაც მოცემული endpoint-ი ელოდება?

ეს ორი სხვადასხვა სახის შემოწმებაა.

მოერიდეთ JSON-ის შექმნას სტრიქონების შეერთებით (concatenation)

კოდში JSON-ის გენერირებისას, დოკუმენტის ხელით აწყობის ნაცვლად, გამოიყენეთ შესაბამისი პროგრამირების ენის JSON-ის სერიალიზატორი.

სტრიქონების შეერთებით შექმნილი მიდგომა არასაიმედოა:

const json = '{"name":"' + name + '","message":"' + message + '"}';

თუ message შეიცავს ბრჭყალებს, უკუდახრილ ხაზებს (backslashes) ან სტრიქონის გადატანის სიმბოლოებს, მათი სწორად ეკრანიზება (escaping) თავად მოგიწევთ.

JavaScript-ში უკეთესი მიდგომაა:

const data = {
name: "Alice",
message: 'She said "hello".'
};

const json = JSON.stringify(data);

Python-ში:

import json

data = {
"name": "Alice",
"message": 'She said "hello".'
}

json_text = json.dumps(data)

სერიალიზატორი თქვენს ნაცვლად უზრუნველყოფს JSON-ის ბრჭყალებისა და ესკეიპ-სიმბოლოების (escaping) წესების დაცვას.

პრობლემების აღმოფხვრის საკონტროლო სია

თუ JSON-ის პარსინგი (დამუშავება) ვერ ხერხდება, შეამოწმეთ შემდეგი პუნქტები:

• გამოტოვებული მძიმეები თვისებებს ან მასივის ელემენტებს შორის
• ზედმეტი მძიმეები } ან ] სიმბოლოების წინ
• ორმაგი ბრჭყალების ნაცვლად გამოყენებული ერთმაგი ბრჭყალები
• ბრჭყალების გარეშე დაწერილი თვისებების სახელები
• გამოტოვებული ორწერტილები
• არასწორად დახურული ან შეუსაბამო {} და [] ფრჩხილები
• სტრიქონებში არსებული ბრჭყალები, რომლებიც არ არის „ესკეიპირებული“ (escaped)
• არასწორი უკუდახრილი ხაზები (backslashes)
• JSON-ის ლიტერალების ნაცვლად გამოყენებული True, False ან None
• კომენტარები
• რამდენიმე მნიშვნელობა უმაღლეს დონეზე (root level)
• ბრჭყალების გარეშე დაწერილი ტექსტური მნიშვნელობები
• რიცხვის არასწორი სინტაქსი
• სტრიქონებში არსებული უშუალო (raw) სტრიქონის გადატანის სიმბოლოები

დიდი ზომის JSON-ის შემთხვევაში, დაიწყეთ Codelope JSON Validator-ით. გამოასწორეთ პირველივე აღმოჩენილი პრობლემა, ხელახლა შეამოწმეთ ვალიდურობა და შემდეგ გამოიყენეთ JSON Formatter საბოლოო სტრუქტურის შესამოწმებლად.

ხშირად დასმული კითხვები

რას ნიშნავს არასწორი (invalid) JSON?

არასწორი JSON არის ტექსტი, რომელიც არღვევს JSON-ის სინტაქსურ წესებს, რის გამოც სტანდარტული JSON-ის პარსერი (დამმუშავებელი) მას ვერ კითხულობს.

რატომ მიჩვენებს JSON შეცდომას „Unexpected token“ (მოულოდნელი ელემენტი)?

პარსერმა აღმოაჩინა სიმბოლო ან მნიშვნელობა, რომელიც მოცემულ ადგილას დაშვებული არ არის. შეამოწმეთ მითითებული ადგილი და მასზე წინ მდებარე ელემენტი — შესაძლოა, შეცდომა სწორედ იქ იწყებოდეს.

შეიძლება თუ არა JSON-ში ბრჭყალებად ერთმაგი ბრჭყალების გამოყენება?

არა. სტანდარტული JSON თვისებების სახელებისა და სტრიქონული მნიშვნელობებისთვის ორმაგ ბრჭყალებს იყენებს.

დაშვებულია თუ არა JSON-ში ბოლო ელემენტის შემდეგ მძიმის (trailing comma) დასმა?

არა. სტანდარტული JSON არ უშვებს მძიმის გამოყენებას ობიექტის ბოლო თვისების ან მასივის ბოლო ელემენტის შემდეგ.

შეიძლება თუ არა JSON-ში კომენტარების ჩართვა?

სტანდარტული JSON არ უჭერს მხარს კომენტარებს. ზოგიერთი JSON-ის მსგავსი კონფიგურაციის ფორმატი უშვებს მათ გამოყენებას, თუმცა ისინი არ უნდა ჩაითვალოს მკაცრ JSON-ად.

რატომ არ იღებს API სწორ JSON-ს?

სინტაქსი შეიძლება სწორი იყოს, მაგრამ მონაცემები არ შეესაბამებოდეს API-ს მიერ მოსალოდნელ სქემას. შეამოწმეთ სავალდებულო ველები, ველების სახელები, მონაცემთა ტიპები, დაშვებული მნიშვნელობები და იერარქიული სტრუქტურა (ჩადგმულობა).

როგორ ვიპოვო შეცდომა დიდ JSON-ფაილში?

ჩასვით JSON Codelope JSON Validator-ში, შეამოწმეთ პირველი მითითებული შეცდომა და მასზე წინ მდებარე ელემენტი, გამოასწორეთ ხარვეზი და ხელახლა შეამოწმეთ ვალიდურობა.

ჯერ JSON-ის ვალიდაცია მოვახდინო თუ ფორმატირება?

ჯერ ვალიდაცია. არასწორი JSON შესაძლოა ფორმატატორმა ვერ დაამუშაოს. ვალიდაციის წარმატებით გავლის შემდეგ გამოიყენეთ Codelope JSON Formatter სტრუქტურის თვალსაჩინო და გასაგები სახით წარმოსაჩენად.