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 ਨਹੀਂ ਹੈ।