ਆਮ JSON ਗਲਤੀਆਂ: ਅੰਤਲੀ ਕਾਮਾ, ਹਵਾਲੇ ਅਤੇ Unexpected token

ਤੁਹਾਡਾ JSON ਗਲਤ ਚਿੰਨ੍ਹਿਤ ਹੈ। ਆਮ ਤੌਰ ਤੇ ਛੋਟੀ ਵਿਆਕਰਣ ਸਮੱਸਿਆ ਹੈ, ਟੁੱਟੀ ਫਾਈਲ ਫਾਰਮੈਟ ਨਹੀਂ। ਹੇਠਾਂ ਸੱਤ ਗਲਤੀਆਂ ਜ਼ਿਆਦਾਤਰ Unexpected token ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ।

JSON ਇੰਨੀ ਆਸਾਨੀ ਨਾਲ ਕਿਉਂ ਟੁੱਟਦਾ ਹੈ?

JSON ਸਖ਼ਤ ਵਿਆਕਰਣ ਵਾਲਾ ਡਾਟਾ ਫਾਰਮੈਟ ਹੈ। JavaScript ਆਬਜੈਕਟ ਲਿਟਰਲ ਮਿਲਦਾ-ਜੁਲਦਾ ਲੱਗ ਕੇ ਵੀ ਗਲਤ JSON ਹੋ ਸਕਦਾ ਹੈ। ਮਿਆਰੀ JSON ਵਿੱਚ ਗੁਣ ਨਾਮਾਂ ਅਤੇ ਸਟਰਿੰਗਾਂ ਨੂੰ ਡਬਲ ਹਵਾਲਾ ਚਾਹੀਦਾ ਹੈ, ਅੰਤਲੀ ਕਾਮਾ ਮਨਜ਼ੂਰ ਨਹੀਂ, ਅਤੇ ਟਿੱਪਣੀਆਂ ਫਾਰਮੈਟ ਦਾ ਹਿੱਸਾ ਨਹੀਂ।

1. ਅੰਤਲੀਆਂ ਕਾਮਾਵਾਂ

ਆਖਰੀ ਗੁਣ ਤੋਂ ਬਾਅਦ ਵਾਧੂ ਕਾਮਾ ਸਮੱਸਿਆ ਹੈ। ਮਿਆਰੀ JSON ਇਸ ਨੂੰ ਮਨਜ਼ੂਰ ਨਹੀਂ ਕਰਦਾ।

ਗਲਤ

{
  "name": "Alex",
  "age": 30,
}

ਸਹੀ

{
  "name": "Alex",
  "age": 30
}

ਉਹੀ ਨਿਯਮ ਐਰੇ ਲਈ ਹੈ। ਆਖਰੀ ਆਈਟਮ ਤੋਂ ਬਾਅਦ ਕਾਮਾ ਹਟਾਓ।

ਗਲਤ

[
  "red",
  "green",
]

ਸਹੀ

[
  "red",
  "green"
]

2. ਡਬਲ ਦੀ ਥਾਂ ਇਕਹਿਰੀ ਹਵਾਲਾ

JavaScript ਅਕਸਰ ਇਕਹਿਰੀ ਹਵਾਲਾ ਮੰਨਦਾ ਹੈ। JSON ਨਹੀਂ। ਗੁਣ ਨਾਮ ਅਤੇ ਸਟਰਿੰਗ ਮੁੱਲ ਡਬਲ ਹਵਾਲਾ ਵਰਤਣ।

ਗਲਤ

{
  'name': 'Alex'
}

ਸਹੀ

{
  "name": "Alex"
}

3. ਬਿਨਾਂ ਹਵਾਲੇ ਗੁਣ ਨਾਮ

JavaScript ਵਿੱਚ ਕਦੇ name ਬਿਨਾਂ ਹਵਾਲੇ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। JSON ਵਿੱਚ ਹਰ ਗੁਣ ਨਾਮ ਡਬਲ-ਹਵਾਲਾ ਸਟਰਿੰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਗਲਤ

{
  name: "Alex",
  age: 30
}

ਸਹੀ

{
  "name": "Alex",
  "age": 30
}

4. ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਗੁੰਮ ਕਾਮਾ

ਗੁਣਾਂ ਅਤੇ ਐਰੇ ਆਈਟਮਾਂ ਵਿਚਕਾਰ ਕਾਮਾ ਚਾਹੀਦੀ ਹੈ। ਪਾਰਸਰ ਅਗਲੀ ਹਵਾਲਾ ਜਾਂ ਬਰੇਸ ਤੇ Unexpected token ਦੱਸ ਸਕਦਾ ਹੈ, ਗੁੰਮ ਕਾਮਾ ਤੇ ਨਹੀਂ।

ਗਲਤ

{
  "name": "Alex"
  "age": 30
}

ਸਹੀ

{
  "name": "Alex",
  "age": 30
}

5. ਘੱਟ ਜਾਂ ਵੱਧ ਬਰੈਕਟ

ਆਬਜੈਕਟ { } ਵਰਤਦੇ ਹਨ। ਐਰੇ [ ]। ਨੈਸਟਡ JSON ਅਕਸਰ ਅਸਫਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ] ਗੁੰਮ ਹੋਵੇ, } ਵੱਧ ਹੋਵੇ, ਜਾਂ ਦੋਵੇਂ ਬਦਲ ਜਾਣ। ਖੁੱਲ੍ਹਣ-ਬੰਦ ਹੋਣ ਜੋੜੇ ਗਿਣੋ।

ਗਲਤ

{
  "items": [1, 2
}

ਸਹੀ

{
  "items": [1, 2]
}

6. ਗਲਤ ਐਸਕੇਪ ਲੜੀਆਂ

JSON ਸਟਰਿੰਗ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਐਸਕੇਪ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। " , \ ਅਤੇ \n ਵਰਗੀਆਂ ਲੜੀਆਂ ਸਹੀ ਹਨ। C:\Users ਲਿਖਿਆ Windows ਪਾਥ ਨਹੀਂ: \U ਕਾਨੂੰਨੀ JSON ਐਸਕੇਪ ਨਹੀਂ। ਬੈਕਸਲੈਸ਼ ਦੁੱਗਣੇ ਕਰੋ, ਨਹੀਂ ਤਾਂ ਪਾਰਸਰ ਉਸ ਅੱਖਰ ਤੇ ਰੁਕਦਾ ਹੈ।

ਗਲਤ

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

ਸਹੀ

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

7. JSON ਅੰਦਰ ਟਿੱਪਣੀਆਂ

ਮਿਆਰੀ JSON ਵਿੱਚ ਟਿੱਪਣੀ ਨਹੀਂ। ਕੁਝ ਕਨਫਿਗ ਟੂਲ // ਜਾਂ /* */ ਮੰਨਦੇ ਹਨ (JSONC, JSON5 ਆਦਿ)। ਉਹ ਮਿਆਰੀ JSON ਨਹੀਂ, ਅਤੇ JSON.parse ਇਨਕਾਰ ਕਰੇਗਾ।

ਗਲਤ

{
  // user name
  "name": "Alex"
}

Unexpected token ਦਾ ਕੀ ਅਰਥ ਹੈ?

ਪਾਰਸਰ ਨੇ ਉਸ ਸਥਾਨ ਤੇ ਅਣਅਧਿਕਾਰਤ ਅੱਖਰ ਵੇਖਿਆ। ਰਿਪੋਰਟ ਕੀਤੀ ਥਾਂ ਉਹ ਹੈ ਜਿੱਥੇ ਪੜ੍ਹਨਾ ਰੁਕਿਆ। ਜੇ ਪਹਿਲਾਂ ਕਾਮਾ ਛੱਡੀ, ਗਲਤੀ ਅਗਲੇ ਗੁਣ ਦੀ ਹਵਾਲੇ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦੀ ਹੈ। ਸ਼ਬਦ ਰਨਟਾਈਮ ਅਨੁਸਾਰ ਬਦਲਦੇ ਹਨ; ਹਰ ਬ੍ਰਾਊਜ਼ਰ ਉਹੀ ਵਾਕ ਛਾਪੇਗਾ ਇਹ ਉਮੀਦ ਨਾ ਕਰੋ।

Unexpected end of JSON input ਦਾ ਕੀ ਅਰਥ ਹੈ?

ਮੁੱਲ ਪੂਰਾ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਲਿਖਤ ਖਤਮ ਹੋ ਗਈ। ਆਮ ਕਾਰਨ: } ਜਾਂ ] ਗੁੰਮ, ਕੱਟਿਆ ਇਨਪੁੱਟ, ਖਾਲੀ ਬਾਡੀ, ਜਾਂ ਟੁੱਟਿਆ API ਜਵਾਬ। ਇਹ ਇੱਕੋ ਬੱਗ ਨਹੀਂ।

JSON.parse() ਕਿਉਂ ਅਸਫਲ ਹੁੰਦਾ ਹੈ?

JSON.parse() ਸਿਰਫ਼ ਸਹੀ JSON ਲਿਖਤ ਮੰਨਦਾ ਹੈ। ਇਹ ਸਫਲ ਹੈ:

const text = '{"name":"Alex"}';
const data = JSON.parse(text);

ਇਹ ਅਸਫਲ ਹੈ, ਕਿਉਂਕਿ ਇਕਹਿਰੀ ਹਵਾਲਾ JSON ਨਹੀਂ:

const text = "{'name':'Alex'}";
JSON.parse(text);

ਸਹੀ ਗਲਤੀ ਸੁਨੇਹਾ JavaScript ਰਨਟਾਈਮ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਸੁਨੇਹੇ ਨੂੰ ਸੰਕੇਤ ਸਮਝੋ, ਫਿਰ ਉਸ ਸਥਾਨ ਕੋਲ ਕਾਮਾ, ਹਵਾਲੇ ਅਤੇ ਬਰੈਕਟ ਵੇਖੋ।

• JSON ਲਿਖਤ
• ↓
• ਪਾਰਸਰ ਟੋਕਨ ਪੜ੍ਹਦਾ ਹੈ
• ↓
• ਸਹੀ ਡਾਟਾ ਜਾਂ Unexpected token

JSON ਗਲਤੀ ਜਲਦੀ ਕਿਵੇਂ ਲੱਭੋ

ਇਸ ਕ੍ਰਮ ਵਿੱਚ ਕੰਮ ਕਰੋ। ਪੂਰੀ ਫਾਈਲ ਮੁੜ ਲਿਖ ਕੇ ਸ਼ੁਰੂ ਨਾ ਕਰੋ।

1. JSON ਨੂੰ ਵੈਲੀਡੇਟਰ ਵਿੱਚੋਂ ਚਲਾਓ।
2. ਪਹਿਲੀ ਰਿਪੋਰਟ ਕੀਤੀ ਗਲਤੀ ਪੜ੍ਹੋ।
3. ਰਿਪੋਰਟ ਕੀਤੇ ਸਥਾਨ ਤੋਂ ਥੋੜ੍ਹਾ ਪਹਿਲਾਂ ਵੇਖੋ।
4. ਕਾਮਾਵਾਂ ਜਾਂਚੋ, ਖਾਸ ਕਰਕੇ ਅੰਤਲੀਆਂ ਅਤੇ ਗੁੰਮ।
5. ਹਵਾਲੇ ਜਾਂਚੋ: ਸਿਰਫ਼ ਡਬਲ।
6. { } ਅਤੇ [ ] ਜੋੜੋ।
7. ਸਟਰਿੰਗਾਂ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਐਸਕੇਪ ਜਾਂਚੋ।
8. ਸਖ਼ਤ JSON ਚਾਹੀਦਾ ਹੋਵੇ ਤਾਂ ਟਿੱਪਣੀਆਂ ਹਟਾਓ।

ਆਮ ਠੀਕਾਂ ਦਾ ਤੁਰੰਤ ਨਕਸ਼ਾ:

ਸਮੱਸਿਆ	ਠੀਕ
ਅੰਤਲੀ ਕਾਮਾ	ਆਖਰੀ ਆਈਟਮ ਤੋਂ ਬਾਅਦ ਕਾਮਾ ਮਿਟਾਓ।
ਇਕਹਿਰੀ ਹਵਾਲਾ	ਨਾਮਾਂ ਅਤੇ ਸਟਰਿੰਗਾਂ ਲਈ ਡਬਲ ਹਵਾਲਾ ਵਰਤੋ।
ਬਿਨਾਂ ਹਵਾਲੇ ਕੁੰਜੀ	ਗੁਣ ਨਾਮ ਨੂੰ ਡਬਲ ਹਵਾਲੇ ਵਿੱਚ ਲਪੇਟੋ।
ਗੁੰਮ ਕਾਮਾ	ਗੁਣਾਂ ਜਾਂ ਐਰੇ ਆਈਟਮਾਂ ਵਿਚਕਾਰ ਕਾਮਾ ਰੱਖੋ।
ਗੁੰਮ ਬਰੈਕਟ	ਹਰ { } ਅਤੇ [ ] ਜੋੜਾ ਬੰਦ ਕਰੋ।
ਗਲਤ ਐਸਕੇਪ	ਕਾਨੂੰਨੀ ਐਸਕੇਪ ਵਰਤੋ, ਜਾਂ ਪਾਥ ਵਿੱਚ ਬੈਕਸਲੈਸ਼ ਦੁੱਗਣੇ ਕਰੋ।
ਟਿੱਪਣੀ	ਮਿਆਰੀ JSON ਲਈ // ਅਤੇ /* */ ਹਟਾਓ।

ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JSON ਜਾਂਚੋ ਅਤੇ ਫਾਰਮੈਟ ਕਰੋ

NEXNARA JSON ਸਜਾਓ / Diff ਇਸ ਡਿਵਾਈਸ ਤੇ JSON ਜਾਂਚ ਸਕਦਾ ਹੈ।

ਤੁਸੀਂ ਜਾਂਚ ਸਕਦੇ ਹੋ, 2 ਸਪੇਸ, 4 ਸਪੇਸ ਜਾਂ ਟੈਬ ਨਾਲ ਸੁੰਦਰ ਕਰ ਸਕਦੇ ਹੋ, minify, ਦੋ ਦਸਤਾਵੇਜ਼ ਤੁਲਨਾ (JSON Diff), ਅਤੇ .json ਫਾਈਲ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ। ਪਾਰਸ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JSON.parse ਵਰਤਦਾ ਹੈ, eval ਨਹੀਂ।

5 MB ਤੋਂ ਵੱਡੇ ਦਸਤਾਵੇਜ਼ ਹੌਲੀ ਲੱਗ ਸਕਦੇ ਹਨ। 15 MB ਤੋਂ ਵੱਡੀ ਲਿਖਤ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਪ੍ਰੋਸੈਸ ਨਹੀਂ ਹੁੰਦੀ, ਤਾਂ ਜੋ ਪੰਨਾ ਜਵਾਬਦੇਹ ਰਹੇ।

JSON ਪ੍ਰੋਸੈਸਿੰਗ ਖੁਦ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦੀ ਹੈ। ਇਸ ਟੂਲ ਲਈ ਲਿਖਤ NEXNARA ਸਰਵਰ ਤੇ ਨਹੀਂ ਭੇਜੀ ਜਾਂਦੀ। ਇਸ਼ਤਿਹਾਰ ਅਤੇ ਹੋਰ ਸਾਈਟ ਫੀਚਰ ਅਜੇ ਵੀ ਨੈੱਟਵਰਕ ਵਰਤਦੇ ਹਨ; ਉਹ ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਵੱਖ ਹੈ।

ਗਲਤ JSON ਜਾਂਚਣਾ ਹੈ? JSON ਸਜਾਓ / Diff ਖੋਲ੍ਹੋ ਅਤੇ ਲਿਖਤ ਚਿਪਕਾਓ।

FAQ

ਮੇਰਾ JSON Unexpected token ਕਿਉਂ ਕਹਿੰਦਾ ਹੈ?

ਪਾਰਸਰ ਨੇ ਉਸ ਥਾਂ ਅਣਅਧਿਕਾਰਤ ਅੱਖਰ ਵੇਖਿਆ। ਅਸਲ ਗਲਤੀ—ਅਕਸਰ ਗੁੰਮ ਕਾਮਾ ਜਾਂ ਇਕਹਿਰੀ ਹਵਾਲਾ—ਉਸ ਸਥਾਨ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ ਹੋ ਸਕਦੀ ਹੈ।

ਕੀ JSON ਵਿੱਚ ਅੰਤਲੀ ਕਾਮਾ ਮਨਜ਼ੂਰ ਹੈ?

ਨਹੀਂ। ਮਿਆਰੀ JSON ਆਖਰੀ ਗੁਣ ਜਾਂ ਐਰੇ ਆਈਟਮ ਤੋਂ ਬਾਅਦ ਕਾਮਾ ਮਨਜ਼ੂਰ ਨਹੀਂ ਕਰਦਾ। JavaScript ਆਬਜੈਕਟ ਲਿਟਰਲ ਅਕਸਰ ਕਰਦੇ ਹਨ।

ਕੀ JSON ਇਕਹਿਰੀ ਹਵਾਲਾ ਵਰਤ ਸਕਦਾ ਹੈ?

ਨਹੀਂ। ਗੁਣ ਨਾਮ ਅਤੇ ਸਟਰਿੰਗਾਂ ਡਬਲ ਹਵਾਲਾ ਵਰਤਣ।

ਕੀ JSON ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ?

ਮਿਆਰੀ JSON ਵਿੱਚ ਨਹੀਂ। ਕੁਝ ਟੂਲ ਟਿੱਪਣੀ ਵਾਲੇ JSONC ਜਾਂ JSON5 ਮੰਨਦੇ ਹਨ; JSON.parse ਫਿਰ ਵੀ ਇਨਕਾਰ ਕਰੇਗਾ।

JSON.parse() ਕਿਉਂ ਅਸਫਲ ਹੁੰਦਾ ਹੈ?

ਸਟਰਿੰਗ ਸਹੀ JSON ਨਹੀਂ। ਆਮ ਕਾਰਨ ਅੰਤਲੀ ਕਾਮਾ, ਇਕਹਿਰੀ ਹਵਾਲਾ, ਬਿਨਾਂ ਹਵਾਲੇ ਕੁੰਜੀਆਂ, ਟਿੱਪਣੀਆਂ, ਜਾਂ ਕੱਟਿਆ ਮੁੱਲ ਹਨ। ਸਹੀ ਸੁਨੇਹਾ ਰਨਟਾਈਮ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

JSON ਸਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਕਿਵੇਂ ਜਾਂਚੋ?

JSON ਸਜਾਓ / Diff ਵਰਗੇ ਵੈਲੀਡੇਟਰ ਵਿੱਚ ਚਿਪਕਾਓ, ਜਾਂ ਕਨਸੋਲ ਵਿੱਚ JSON.parse ਬੁਲਾਓ। ਜੇ ਪਾਰਸ ਸੁੱਟੇ ਤਾਂ ਲਿਖਤ ਸਹੀ JSON ਨਹੀਂ।