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 ಅಲ್ಲ.