JSON ಮಾನ್ಯತೆಕರಣ ಉಪಕರಣ

JSON ಮಾನ್ಯತೆ ಎಂದರೆ ಏನು?

JSON (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ನೋಟೇಶನ್) ಒಂದು ವೈಶಾಲ್ಯವಾಗಿ ಎನ್ನುತ್ತಿರುವ, ತೂಕಹೀನ ಡೇಟಾ ವಿನಿಮಯ ಸ್ವರೂಪವಾಗಿದೆ, ಇದು ಮಾನವರು ಓದಲು ಸುಲಭವಾಗಿದ್ದು, ಯಂತ್ರಗಳು解析ಮಾಡಲು ಮತ್ತು ರಚಿಸಲು ಸರಳವಾಗಿದೆ. ಇದರ ಮುಖ್ಯ ಉದ್ದೇಶವು ರಚನಾತ್ಮಕ ಡೇಟಾವನ್ನು—ಆಬ್ಜೆಕ್ಟ್‌ಗಳು, ಅರೆ, ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಸಂಖ್ಯೆ, ಬೂಲಿ ಮೌಲ್ಯಗಳು ಮತ್ತು ನಲ್—ಭಾಷಾ ನಿರಪೇಕ್ಷ ಸ್ವರूपದಲ್ಲಿ ಪ್ರತಿನಿಧಿಸುವುದಾಗಿದೆ.

JSON ಮಾನ್ಯತೆ ಎಂದರೆ JSON ಡಾಕ್ಯುಮೆಂಟ್ ವ್ಯಾಕರಣಾತ್ಮಕವಾಗಿಯೂ ರಚನಾತ್ಮಕವಾಗಿಯೂ ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ಪ್ರೋಗ್ರಾಮ್ ಮೂಲಕ ಪರಿಶೀಲಿಸುವ ಪ್ರಕ್ರಿಯೆ. ಇದರಲ್ಲಿ ಮುಖ್ಯವಾಗಿ ಎರಡು ಅಂಶಗಳನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ:

• ವಾಕ್ಯರಚನೆ ಪರಿಶೀಲನೆ: ಕೂಡಲೆಲ್ಲಳಿತದ ಫಾರ್ಮಲ್ ವ್ಯಾಕರಣವನ್ನು ಅನುಸರಿಸುವಂತೆ ಕಚ್ಚಾ ಪಠ್ಯವನ್ನು ಖಚಿತಪಡಿಸುವುದು, ಇದು ECMA-404 JSON ನಿರ್ದಿಷ್ಟರಣೆಗಳಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿನ ಪಾರ್ಸರ್‌ಗಳು (ಉದಾಹರಣೆ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ JSON.parse(), ಪೈಥಾನ್‌ನ json.loads(), ಜ್ಯಾಂಗೆ ಸಭೆಗೆ JSONDecoder) ಮಾನ್ಯವಾದ ವ್ಯಾಕರಣವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತವೆ ಮತ್ತು ಯಾದೃಚ್ಛಿಕವಾದ ಇನ್ಪುಟ್ ಇದ್ದರೆ ದೋಷಗಳನ್ನು ತೋರಿಸುತ್ತವೆ.
• ರಚನಾತ್ಮಕ (ಸ್ಕೀಮಾ) ಮಾನ್ಯತೆ: ವ್ಯಾಕರಣದ ಹೊರತಾಗಿ, ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆ JSON ಡೇಟಾದು ನಿರೀಕ್ಷಿತ ರಚನೆಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಡೇಟಾ ಪ್ರಕಾರಗಳು, ಅಗತ್ಯವಾದ ಗುಣಲಕ್ಷಣಗಳು, ಮೌಲ್ಯ ನಿರ್ಬಂಧಗಳು ಮತ್ತು ನೆಸ್ಟ್ ಮಾಡಿದ ವಸ್ತುಗಳು/ಸರಣಿಗಳೂ ಸೇರಿವೆ. ಸ್ಕೀಮಾ ಪರಿಶೋಧನೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ JSON ಸ್ಕೀಮಾ ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ, ಇದು ಕಡ್ಡಾಯವಾಗಿರುವ ಮಾನ್ಯ ಡೇಟಾ ನಿಯಮಗಳನ್ನು ನಿರ್ಣಯಿಸುತ್ತದೆ.

JSON ಅನ್ನು ಯಾಕೆ ಪರಿಶೀಲಿಸಬೇಕು?

ಡೇಟಾವನ್ನು ಪ್ರಸಾರ, ಸಂಗ್ರಹಣೆ ಅಥವಾ ಸೇವೆಗಳ ನಡುವೆ ಸಂವಹನದಿಗಾಗಿ ಸೀರಿಯಲೈಸ್ ಮಾಡುವಾಗ JSON ಪ್ರಮಾಣೀಕರಣ ಅತ್ಯಾವಶ್ಯಕವಾಗಿದೆ. ಪ್ರಮುಖ ಕಾರಣಗಳು ಫಾಲೋವ್ ಆಗಿವೆ:

• ದೋಷ ನಿರ್ಮೂಲನೆ: ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೊದಲು, ವಾಕ್ಯರಚನಾ ದೋಷಗಳನ್ನು (ಉದಾ: ಕಮ್ಮಿಗಳ ಕೊರತೆ, ಹೊಂದಿಕೆಯಾಗದ ನಾಯಿಗಳ ಬ್ರಾಕೆಟ್‌ಗಳು, ಅಕ್ರಮ ಅಕ್ಷರಗಳು) ತ್ವರಿತವಾಗಿ ಪತ್ತೆಮಾಡಿ ವರದಿ ಮಾಡಿ.
• ದತ್ತಾಂಶ ಏಕತೆಯು ಮತ್ತು ಸುರಕ್ಷತೆ: ತಪ್ಪಾದ ಅಥವಾ ಅಪಾಯಕಾರಿ JSON ಪೇಲೋಡ್‌ಗಳನ್ನು ನಿರಾಕರಿಸಿ, ಬ್ಯಾಕ್‌ಎಂಡ್ ಡೌನ್‌ ಆಗುವುದು, ಹಾಳು ಸಂಗ್ರಹಣೆ ಅಥವಾ ಡೇಟಾ ಕಪಟವನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಟೈಪ್ ಸುರಕ್ಷತೆ: ಕಠಿಣ ಟೈಪಿಂಗ್ ಅನಿವಾರ್ಯಗೊಳಿಸಿ—ಉದಾಹರಣೆಗೆ, κάποιο ಕ್ಷೇತ್ರವು ಬೂಲಿಯನ್ ಆಗಿರಬೇಕೆಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಏಕೆಂದರೆ ಅದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಕಳುಹಿಸಲಾಗದಂತೆ, ಅಥವಾ UUIDಗಳು, ಇಮೇಲ್‌ಗಳೂ, ಸಂಖ್ಯೆಗಳೂ ಸರಿಯಾದ ಸ್ವರೂಪದಲ್ಲಿ ಇರಲೇಬೇಕೆಂದು ನೋಡುವುದು.
• ಭಾಷಾಂತರರಹಿತ ಹೊಂದಾಣಿಕೆ: ಒಂದೇ ವಾತಾವರಣದಲ್ಲಿ (ಉದಾಹರಣೆಗೆ, Node.js) ಉತ್ಪನ್ನವಾದ JSON ಅನ್ನು ಇನ್ನೊಂದು ವಾತಾವರಣದಲ್ಲಿ (ಉದಾಹರಣೆಗೆ, Python, Go, Java) ಸುರಕ್ಷಿತವಾಗಿ ಬಳಸಬಲ್ಲ ರೀತಿಯಲ್ಲಿ ಖಚಿತಪಡಿಸಿ, ಸೀರಿಯಲೈಜೆಷನ್/ಡಿಯೂರಿಯಲೈಜೆಷನ್ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಿ.
• ನಿರ್ವಹಣೆ ಮತ್ತು ಭರ್ಜರತೆ: ಪರಿಶೀಲಿತ ಡೇಟಾ ರಚನೆಗಳು ಹಾದಿಮಾರಿಗೆ ಸುಗಮತೆ ನೀಡುತ್ತವೆ ಮತ್ತು ಸಂರಚನಾ ಫೈಲುಗಳು, ಲಾಗ್‌ಗಳು ಅಥವಾ API ವಿನಂತಿಗಳು/ಪ್ರತಿಕ್ರಿಯೆಗಳಲ್ಲಿನ ಕುಷ್ಟಿಪಡಿಸಲು ಕಷ್ಟವಾದ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತವೆ.
• ಗೋಪ್ಯತೆ ಮತ್ತು ಭದ್ರತೆ: ಪರಿಶೀಲನೆ ಸಂಪೂರ್ಣವಾಗಿ ಕ್ಲೈಂಟ್-ಸೈಡ್‌ನಲ್ಲಿ (ಬ್ರೌಸರ್‌ನಲ್ಲಿ) ನಡೆಯಬಹುದು, ಬಳಕೆದಾರರ ಸಾಧನದಿಂದ ಆರಂಭಿಕ ಅಥವಾ ಸಂವೇದನಾಶೀಲ ಡೇಟಾ ಪರಿಶೀಲನೆಗಾಗಿ ಹೊರಬರದಂತೆ ತಡೆಯುತ್ತದೆ.

ಸಾಮಾನ್ಯ JSON ಪರಿಶೋಧನಾ ದೋಷಗಳು (ವಿಸ್ತೃತ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ)

ಉಲ್ಲೇಖವಿಲ್ಲದ ಕೀಗಳು

JSON ವಸ್ತುಗಳಲ್ಲಿನ ಎಲ್ಲಾ ಕೀಗಳು ಎರಡುಗುಂಡುವುವಿನ ಉಲ್ಲೇಖದ ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿರಬೇಕು.

{ name: "ಆಲಿಸ್" }

{ "name": "ඇලಿಸ್" }

ಬಹುತೇಕ JSON-ನ ತರಹದ ಫಾರ್ಮ್ಯಾಟ್ಗಳು (ಉದಾಹರಣೆಗೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಲಿಟರೆಲ್ಸ್) ಉತ್ತರಿಸಿದ ಕೀಯಗಳನ್ನು ಅನುಮತಿಸುತ್ತವೆ, ಆದರೆ ಪ್ರಾಮಾಣಿಕ JSON ಇದನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ.

ಒಂದು ಉಲ್ಲೇಖ ಚಿಹ್ನೆಗಳು

JSON ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಕೇವಲ ದ್ವಿಗುಣ ಉಲ್ಲೇಖಗಳನ್ನು ಮಾತ್ರ ಬಳಸಬೇಕು; ಏಕಕೋಟ್‌ಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ.

{ 'ಹೆಸರು': 'ಬೋಬ್' }

{ "name": "ಬಾಬ್" }

ಒಂದು ಉದ್ಘಾಟನೆ ಚಿಹ್ನೆಗಳ ಬಳಕೆಯಿಂದ ಎಲ್ಲಾ ಅನುಕೂಲಕರ JSON ಲೈಬ್ರೆರಿಗಳಲ್ಲೂ ಪಾರ್ಸರ್ ದೋಷಗಳು ಸಂಭವಿಸುವುವು.

ಕೊನೆಗಿನ ಕೊಮಗಳು

ಒಬ್ಬ ವಸ್ತುವಿನ ಅಥವಾ ಸರಣಿಯ ಕೊನೆಯ ಐಟಂ ನಂತರ ಯಾವುದೇ ಕೊನೆಯಲ್ಲಿ ಅಲ್ಪವಿರಾಮ ಇರಬಾರದು.

{
  "a": 1,
  "b": 2,
}

{
  "a": 1,
  "b": 2
}

ಟ್ರೇಲಿಂಗ್ ಕಾಮಾಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು, ಆದರೆ ಕಠಿಣ JSON ಪಾರ್ಸರ್‌ಗಳಲ್ಲಿ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.

ಅಸ್ವೀಕೃತವಾಗಿರುವ ಅಕ್ಷರಗಳ ನಿರ್ಗಮನ

ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಒಳಗಿನ ಉಕ್ತಿಗಳು ಮತ್ತು ವಿಶೇಷ ಅಕ್ಷರಗಳನ್ನು ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್ ಬಳಸಿ ಎಸ್ಕೇಪ್ ಮಾಡಬೇಕು.

{ "quote": "ಟಾಮ್ ಹೀಗಂದನು \"ನಮಸ್ಕಾರ\"" }

{ "quote": "ಟಾಮ್ ಹೇಳಿದರು \"ಹೆಲೋ\"" }

ಇತರೆ ದೊರಿಕಿಹಾಕುವ ಕ್ರಮಗಳಲ್ಲಿ ಬೆಕ್‌ಸ್ಲ್ಯಾಶ್‌ಗೆ \\ , ಹೊಸ ಸಾಲುಗಳಿಗೆ \n , ಮತ್ತು ಟ್ಯಾಬ್‌ಗಳಿಗೆ \t ಸೇರಿವೆ.

ತಪ್ಪಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಸಂಖ್ಯೆಗಳು, ಬೂಲಿಯನ್‌ಗಳು ಅಥವಾ ನಲ್‌ಗಳಿಗೆ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸಬಾರದು.

{ "enabled": "ಸಕ್ರಿಯಗೊಂಡಿದೆ", "count": "10" }

{ "ಸಕ್ರಿಯ": ನಿಜ, "ಎಣಿಕೆ": 10 }

JSON ಬೂಲಿಯನ್‌ಗಳು, ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ವಿಭಜಿಸುತ್ತದೆ—ಸರಿಯಾದ ಪ್ರಕಾರವನ್ನು ಬಳಸುತ್ತಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಅಪ್ರಾಥಮಿಕ ಕೀಗಳು

JSON ವಸ್ತು ಕೀಲಿಗಳು ಸದಾ ಪಠ್ಯ ಸರಣಿಗಳಾಗಿರಬೇಕು; ನೀವು ಸಂಖ್ಯೆಗಳು, ಬೂಲಿಯನ್‌ಗಳು ಅಥವಾ ಇತರ ಪ್ರಕಾರಗಳನ್ನು ಕೀಲಿಗಳಾಗಿ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

{ 123: "abc" }

{ "123": "ಎಬಿಸಿ" }

ನಕಲಿ ಕೀಗಳು

JSON ಸ್ಪೆಕ್ ಅನುಮತಿಸುವುದಾದರೂ, ನಕಲಿ ಕೀಗಳು ಸಾಮಾನ್ಯವಾಗಿ ದೋಷಗಳ ಮೂಲವಾಗುತ್ತವೆ.

{ "name": "ಆಲಿಸ್", "name": "ಬಾಬ್" }

ಬಹುಪಾಲು ಪಾರ್ಸರ್‌ಗಳು ಕೇವಲ ಕೊನೆಯ ಮೌಲ್ಯವನ್ನು ("ಬಾಬ್") ಮಾತ್ರ ಉಳಿಸಿಕೊಂಡು, ಇಲ್ಲಿನ ಮುಂಚಿನ ಮೌಲ್ಯಗಳನ್ನು ನಮಿತ್ತವಾಗಿ ಇಗೋಡಿಸುತ್ತವೆ.

ಟಿಪ್ಪಣಿಗಳ ಬಳಕೆ

ಸಾಮಾನ್ಯ JSON ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ, ಆದರೂ ಕೆಲವು ಸಂಪಾದಕರು ಅವುಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತಾರೆ.

{
  // ಬಳಕೆದಾರರ ಮಾಹಿತಿ
  "name": "ಅಲಿಸ್"
}

{
  "name": "ಎಲಿಸ್"
}

ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆ: ರಚನೆ ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಜಾರಿ ಮಾಡುವುದರೊಂದಿಗೆ

JSON ಸ್ಕೀಮಾ হল JSON ದಸ್ತಾವೇಜುಗಳ ನಿರೀಕ್ಷಿತ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ಮಾನ್ಯತೆಗೊಳಿಸಲು ಶಕ್ತಿಶಾಲಿ ಮಾನದಂಡವಾಗಿದೆ. ಇದು ನಿಮಗೆ ಹೀಗೆ ನಿರ್ಧರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ:

• ಅಗತ್ಯವಾದ ಕ್ಷೇತ್ರಗಳು (`required`)
• ಡೇಟಾ ಪ್ರಕಾರಗಳು (`type`: ಸ್ಟ್ರಿಂಗ್, ಸಂಖ್ಯೆ, ಬೂಲೀಿಯನ್, ವಸ್ತು, ಸರಣಿ, ಶೂನ್ಯ)
• ಸ್ಟ್ರಿಂಗ್ ಸ್ವರೂಪಗಳು (`format`: ಇಮೇಲ್, UUID, ದಿನಾಂಕ-ಸಮಯ, ಇತ್ಯಾದಿ)
• ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಮಾದರಿ ಹೊಂದಿಸುವಿಕೆ (`pattern`)
• ಸಂಖ್ಯಾ ವ್ಯಾಪ್ತಿಗಳು (`ಕನಿಷ್ಠ`, `ಗರಿಷ್ಠ`)
• ಅರೆ ಮೂಲದ দৈರ್ಘ್ಯ ಮತ್ತು ಐಟಂ ಪರಿಶೀಲನೆ (`ನಿಖರಐಟಂಗಳು`, `ಗರಿಷ್ಠಐಟಂಗಳು`, `ಐಟಂಗಳು`)
• ವಸ್ತುಗಳು ಮತ್ತು ಸರಣಿಗಳ ಗೂಢಾಚಾರದ ಪರಿಶೀಲನೆ
• ಎನುಮ್ ನಿರ್ಬಂಧಗಳು (`enum`)

ಉದಾಹರಣೆ: ಬಳಕೆದಾರರ schemas (ಡ್ರಾಫ್ಟ್-07)

{
  "type": "object",
  "properties": {
    "id":    { "type": "string", "format": "uuid" },
    "name":  { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "is_active": { "type": "boolean" }
  },
  "required": ["id", "name", "email"],
  "additionalProperties": false
}

ಇದರಿಂದ ಜಾರಿಗೊಳ್ಳುವುದು:

• ಐಡಿ ಮಾನ್ಯ UUID ಸ್ಟ್ರಿಂಗ್ ಆಗಿರಬೇಕು.
• ಹೆಸರು ಖಾಲಿ olmayan ಅಕ್ಷರಸಂಕೇತವಾಗಿರಬೇಕು.
• ಇಮೇಲ್ ಮಾನದಂಡದ ಇಮೇಲ್ ಮಾದರಿಯನ್ನು ಹೊಂದಿರಬೇಕು.
• is_active (ಐಚ್ಛಿಕ) ಒಂದು ಬೂಲಿಯನ್ ಆಗಿರಬೇಕು.
• ಮೇಲಿನ ವ್ಯಾಖ್ಯಾನಿಸಿದ ಬದಲಿಗೆ ಯಾವುದಾದರೂ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ.

ವಾಸ್ತವಿಕ ಉದಾಹರಣೆ: ಸ್ಟ್ರೈಪ್ API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಮಾನ್ಯಗೊಳಿಸುವುದು

ನೀವು ಸ್ಟ್ರೈಪ್ API (ಉದಾಹರಣೆಗೆ, ಪೇಮೆಂಟ್ ಇಂಟೆಂಟ್) ನಿಂದ JSON ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತಿದರೆ ಎಂದು فرض ಮಾಡಿಕೊಳ್ಳಿ. ಸ್ಕೀಮಾ ಮಾನ್ಯತೆ ಮೂಲಕ ನೀವು ಯಾವುದಾದರೂ ಅಪೂರ್ಣ ಅಥವಾ ತಪ್ಪಾಗಿ ಟೈಪ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಮಾಡದೇ ಇರಬಹುದು.

{
  "type": "ವಸ್ತು",
  "properties": {
    "id":      { "type": "ഘടകം", "pattern": "^pi_" },
    "object":  { "type": "ഘടകം", "const": "ಪಾವತಿ_ಉದ್ದೇಶ" },
    "amount":  { "type": "ಪೂರ್ಣಾಂಕ", "minimum": 1 },
    "currency":{ "type": "ഘടകം", "minLength": 3, "maxLength": 3 },
    "status":  { "type": "ഘടകം", "enum": [
      "ಪಾವತಿ_ಮಾತು_ಬೇಕಾಗಿದೆ",
      "ದೃಢೀಕರಣ_ಬೇಕಾಗಿದೆ",
      "ಪ್ರಕರ್ತನೆಯಲ್ಲಿ",
      "ಯಶಸ್ವಿಯಾಗಿ_ನಿರ್ವಹಿಸಲಾಗಿದೆ",
      "ರದ್ದುಗೊಳಿಸಲಾಗಿದೆ"
    ]}
  },
  "required": ["id", "object", "amount", "currency", "status"],
  "additionalProperties": false
}

• id "pi_" ಅಕ್ಷರಗಳಿಂದ ಆರಂಭವಾಗಬೇಕು
• ವಸ್ತುವಿನ ಮೌಲ್ಯವು ಸದಾ "payment_intent" ಆಗಿರಬೇಕು
• ಮೊತ್ತವು 1ಕ್ಕೆ ಸಮಾನ ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಪೂರ್ಣಾಂಕವಾಗಿರಬೇಕು
• ಮುದ್ರೆ ಮೂರು ಅಕ್ಷರಗಳ ಸ್ಟ್ರಿಂಗ್ ಆಗಿರಬೇಕು (ಉದಾ: "usd", "eur")
• ಸ್ಥಿತಿ ಸೂಚಿಸಿರುವ ಮೌಲ್ಯಗಳ ішінде ಒಂದಾಗಿರಬೇಕು

ಲಾಭಗಳು

• ಮುಂಚಿತ ದೋಷ ಪತ್ತೆ: ನಿಮ್ಮ ವ್ಯವಹಾರ ನಿಯಮಗಳಿಗೆ ತಲುಪುವ ಮೊದಲು ಮುರಿಯುವ API ಬದಲಾವಣೆಗಳು ಅಥವಾ ಅಪೂರ್ಣ ಡೇಟಾವನ್ನು ಹಿಡಿಯಿರಿ.
• ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆ:ವಾಸ್ತವ ಮತ್ತು ನಕಲಿ ಪ್ರತಿಕ್ರಿಯೆಗಳ ನಿಖರತೆಗೆ ಸಿಐ/ಸಿಡಿ ಪೈಪ್ಲೈನಿನಲ್ಲಿ ಸ್ಕೀಮಾಗಳನ್ನು ಬಳಸಿರಿ.
• ಅಂತರ ತಂಡಗಳ ಸಾಂದರ್ಭಿಕತೆ: ಮುಂಭಾಗ, ಹಿಂತಲಾಗು ಮತ್ತು ಮೂರನೇ ಪಕ್ಷದ APIs ನಡುವೆ ಡೇಟಾ ಒಪ್ಪಂದಗಳನ್ನು ಮಾನಕೀಕೃತಗೊಳಿಸಿ.

ಸರಿಯಾದ JSON ಮಾನ್ಯತೆ—ವು both ವಾಕ್ಯರಚನೆ ಮತ್ತು_SCHEMA ಅನ್ನು ಒಳಗೊಂಡಂತೆ—ಸುಕ್ಷ್ಮ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ, ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಜಾರಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಆಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ತಪ್ಪಾದ ಅಥವಾ ದುಷ්ಟ ಉಲ್ಲೇಖಗಳಿಂದ ರಕ್ಷಿಸುತ್ತದೆ. ಸಂರಚನಾ ಕಡತಗಳು, API ಪಾಯ್ಲೋಡ್ಗಳು ಅಥವಾ ಸರ್ವಿಸ್‌ಗಳ ಮಧ್ಯೆ ಸಂದೇಶವಾಹಕವಾಗಿ ಬಳಸಿದ್ದು, ಮೂರನೇ ಮಾನ್ಯತೆ ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಮೂಲಭೂತವಾಗಿದೆ.

ಗೋಪ್ಯತೆ ಮತ್ತು ಭದ್ರತೆ

ಎಲ್ಲಾ ಮಾನ್ಯತೆ ಮತ್ತು ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆಗಳು ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ನಡೆಯುತ್ತವೆ. ಯಾವುದೇ ಡೇಟಾ ಅಪ್ಲೋಡ್ ಅಥವಾ ಲಾಗ್ ಆಗುವುದಿಲ್ಲ. ನಿಮ್ಮ JSON ಸಂಪೂರ್ಣ ಗೌಪ್ಯವಾಗಿರುತ್ತದೆ.

JSON ಮಾನ್ಯತೆಗಾಗಿ ಕೋಡ್ ಉದಾಹರಣೆಗಳು

ಎದುರಿಸಾವೇಲೆ ಫ್ರೇಮ್ವರ್ಕ್‌ಗಳು ಮತ್ತು ಬಿಲ್ಟ್-ಇನ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ JSON ಅನ್ನು ಯಥಾರ್ಥಗೊಳಿಸುವ ವಿಧಾನವನ್ನು ನೋಡಿ. ಈ ಉದಾಹರಣೆಗಳು ಸಿಂಟ್ಯಾಕ್ಸ್ ಮಾನ್ಯತೆ ಮತ್ತು ಸ್ಕೀಮಾ ಮಾನ್ಯತೆಯನ್ನು ಎರಡನ್ನೂ ಪ್ರದರ್ಶಿಸುತ್ತವೆ.

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

const Ajv = require("ajv");
const ajv = new Ajv();
const schema = { type: "object", properties: { age: { type: "integer" } }, required: ["age"] };
const data = { age: 30 };
const validate = ajv.compile(schema);
console.log(validate(data) ? "Valid!" : ajv.errorsText(validate.errors));

import json
try:
    obj = json.loads('{"name":"Alice","age":30}')
    print("Valid JSON:", obj)
except json.JSONDecodeError as e:
    print("Invalid JSON:", e)

import json, jsonschema
schema = {
    "type": "object",
    "properties": { "age": { "type": "integer" } },
    "required": ["age"]
}
data = {"age": 30}
try:
    jsonschema.validate(data, schema)
    print("Valid!")
except jsonschema.ValidationError as e:
    print("Schema validation error:", e)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  data := []byte(`{"name":"Alice","age":30}`)
  var obj map[string]interface{}
  if err := json.Unmarshal(data, &obj); err != nil {
    fmt.Println("Invalid JSON:", err)
  } else {
    fmt.Println("Valid JSON:", obj)
  }
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) {
    String json = "{\"name\":\"Alice\",\"age\":30}";
    try {
      Object obj = new ObjectMapper().readTree(json);
      System.out.println("Valid JSON: " + obj);
    } catch (Exception e) {
      System.out.println("Invalid JSON: " + e.getMessage());
    }
  }
}

using System;
using System.Text.Json;
class Program {
  static void Main() {
    string json = "{\"name\":\"Alice\",\"age\":30}";
    try {
      using var doc = JsonDocument.Parse(json);
      Console.WriteLine("Valid JSON!");
    } catch (JsonException e) {
      Console.WriteLine("Invalid JSON: " + e.Message);
    }
  }
}

<?php
$json = '{"name":"Alice","age":30}';
$obj = json_decode($json);
if (json_last_error() === JSON_ERROR_NONE) {
  echo "Valid JSON";
} else {
  echo "Invalid JSON: " . json_last_error_msg();
}

require 'json'
begin
  obj = JSON.parse('{"name":"Alice","age":30}')
  puts "Valid JSON!"
rescue JSON::ParserError => e
  puts "Invalid JSON: #{e.message}"
end

echo '{"name":"Alice","age":30}' | jq empty && echo "Valid" || echo "Invalid"

fn main() {
  let data = r#"{"name":"Alice","age":30}"#;
  match serde_json::from_str::<serde_json::Value>(data) {
    Ok(_) => println!("Valid JSON!"),
    Err(e) => println!("Invalid JSON: {}", e),
  }
}

import org.json.JSONObject
fun main() {
  try {
    val obj = JSONObject("{\"name\":\"Alice\",\"age\":30}")
    println("Valid JSON: $obj")
  } catch (e: Exception) {
    println("Invalid JSON: ${e.message}")
  }
}

import Foundation
let json = "{\"name\":\"Alice\",\"age\":30}"
if let data = json.data(using: .utf8) {
  do {
    let _ = try JSONSerialization.jsonObject(with: data)
    print("Valid JSON!")
  } catch {
    print("Invalid JSON: \(error)")
  }
}

const jsonString = '{"name":"Alice","age":30}';
try {
  const obj = JSON.parse(jsonString);
  console.log("Valid JSON:", obj);
} catch (e) {
  console.error("Invalid JSON!", e.message);
}

SELECT '{"name":"Alice","age":30}'::jsonb; -- Will error if not valid JSON

SELECT JSON_VALID('{"name":"Alice","age":30}');

$json = '{"name":"Alice","age":30}'
try {
  $obj = $json | ConvertFrom-Json
  Write-Output "Valid JSON!"
} catch {
  Write-Output "Invalid JSON: $($_.Exception.Message)"
}

use JSON;
my $str = '{"name":"Alice","age":30}';
eval { decode_json($str) };
print $@ ? "Invalid JSON: $@" : "Valid JSON!";

import 'dart:convert';
void main() {
  const jsonString = '{"name":"Alice","age":30}';
  try {
    final obj = jsonDecode(jsonString);
    print('Valid JSON: $obj');
  } catch (e) {
    print('Invalid JSON: $e');
  }
}

json = ~s({"name":"Alice","age":30})
case Jason.decode(json) do
  {:ok, _} -> IO.puts("Valid JSON!")
  {:error, err} -> IO.puts("Invalid JSON: #{err}")
end

import play.api.libs.json._
object Main extends App {
  val str = """{"name":"Alice","age":30}"""
  try {
    val json = Json.parse(str)
    println("Valid JSON!")
  } catch {
    case e: Exception => println("Invalid JSON: " + e.getMessage)
  }
}

ಈ ಉಪಕರಣದ ಬಗ್ಗೆ