JSON ಫಾರ್ಮ್ಯಾಟರ್

JSON ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಎಂದರೆ ಏನು?

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

ನಿರೀಕ್ಷೆಯಂತೆ, JSON ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳ ಹೊರಗಿನ ವೈಟ್ ಸ್ಪೇಸ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ. ಆದರೆ, ದುರ್ಬಳಕೆಮಾಡಿದ ಅಥವಾ ಮಿನಿಫೈಗೊಂಡ JSON, ಇಂದೆಂಟೇಶನ್ ಇಲ್ಲದೆ ಅಥವಾ ಒಟ್ಟಾರಿಗೆ ಒಗ್ಗೂಡಿಸಿದಾಗ, ಮಾನವರಿಗೆ ಓದುತ್ತಾ ಅಥವಾ ಬದಲಾಯಿಸುತ್ತಾ ಬಹಳವುದಾಗಿ ಸವಾಲಾಗುತ್ತದೆ.

JSON ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು ಮತ್ತು ಮಿನಿಫೈ ಮಾಡುವುದು

• ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಓದುಗರತೆಗೆ ವೈಟ್ ಸ್ಪೇಸ್, ಇಂದೆಂಟೇಶನ್ ಮತ್ತು ಸಾಲು ವಿರಾಮಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.
• ಮಿನಿಫೈ ಅತಿರೇಕದ ವೈಟ್ ಸ್ಪೇಸ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿ ಸಂಗ್ರಹಣೆ ಅಥವಾ ವರ್ಗಾವಣೆಗಾಗಿ ಗರಿಷ್ಠ ಸಂಕ್ಷಿಪ್ತತೆ ತರುತ್ತದೆ.
• ಬಲವಾದ JSON ಫಾರ್ಮ್ಯಾಟರ್ ಈ ಎರಡೂ ರೀತಿಗಳನ್ನು ಸರಳವಾಗಿ ಬದಲಾಯಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಮಾನವ ಸ್ನೇಹಿ ಮತ್ತು ಯಂತ್ರ ನಿಖರ ಆವೃತ್ತಿಗಳ ನಡುವೆ ಸುಲಭ ಸ್ವಿಚ್ ಮಾಡಬಹುದು.

ಉದಾಹರಣೆ: ಮಿನಿಫೈ ಮಾಡಿದ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ JSON

{"id":"3f4b2c","user":{"name":"Dana","is_active":true},"roles":["admin","editor"],"count":7}

{
  "id": "3f4b2c",
  "user": {
    "name": "Dana",
    "is_active": true
  },
  "roles": [
    "admin",
    "editor"
  ],
  "count": 7
}

JSON ಅನ್ನು ಏಕೆ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಬೇಕು?

• ಓದುಗಾರಿಕೆ: ಸರಿಯಾದ ಇಂದೆಂಟೇಶನ್ ಮತ್ತು ಸಾಲು ವಿರಾಮಗಳಿಂದ ಕಾಳಾಜಿದ ಅಂಶಗಳು ಸುಲಭವಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತವೆ, ತಪ್ಪುಗಳ ಗುರುತಿಸುವಿಕೆ, ಮತ್ತು ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯವಾಗುತ್ತದೆ.
• ಡಿಬಗ್ಗಿಂಗ್: ಅನಿಯಮಿತ ಅಥವಾ ನಿರೀಕ್ಷಿತವಲ್ಲದ ಡೇಟಾವನ್ನು ಈ JSON ಅನ್ನು ದೃಶ್ಯವಾಗಿ ಪರಿಶೀಲಿಸುವುದರಿಂದ ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಬಹುದಾಗಿದೆ.
• ಸಹಯೋಗ: ಸರಿಯಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ JSON ಅನ್ನು ಕೋಡ್ ವಿಮರ್ಶೆಗಳಲ್ಲಿ, ದಸ್ತಾವೇಜುಗಳಲ್ಲಿ, ಅಥವಾ ಹಂಚಿಕೊಳ್ಳಲಾದ ಕಡತಗಳಲ್ಲಿ ವಿಮರ್ಶಿಸಲು ಮತ್ತು ಚರ್ಚಿಸಲು ಸುಲಭ.
• ವರ್ಷನ್ ನಿಯಂತ್ರಣ: Git ಮತ್ತು ಇತರೆ VCS ಉಪಕರಣಗಳು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ JSON ಮೂಲಕ ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣ ಬದಲಾವಣೆಗಳ ಡಿಫ್ ಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತವೆ, ಇದು ಸಮಯದೊಂದಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಹತ್ತಿರವಾಗಿಡಲು ನೆರವಾಗುತ್ತದೆ.
• ಅನುಕೂಲತೆ: ಬಹುಮಟ್ಟದ ಶೈಲಿ ಮಾರ್ಗದರ್ಶಿಗಳು ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಲಿಂಟರ್‌ಗಳು (Prettier, ESLint, jq ಇತ್ಯಾದಿ) ಸಾಮರಸ್ಯಕ್ಕಾಗಿ ನಿರಂತರ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಜಾರಿ ಮಾಡುತ್ತವೆ.
• ಉಪಕರಣ ಹೊಂದಿಕೊಳ್ಳುವಿಕೆ: ಕೆಲವು APIಗಳು, CLIಗಳು ಮತ್ತು ಸಂಪಾದಕರು ಮಾನವ ಸಂವಹನ ಅಥವಾ ಲಾಗಿಂಗ್‌ಗಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಇನ್‌ಪುಟ್ ಅನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತವೆ.

JSON ಫಾರ್ಮ್ಯಾಟರ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

1. ಪಾರ್ಸಿಂಗ್: ಪ್ರಮುಖ JSON ಪಾರ್ಸರ್ ಬಳಸಿ ನಿಮ್ಮ ಇನ್‌ಪುಟ್ ಪಠ್ಯವನ್ನು ಮೊದಲಿಗೆ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ. ಇದು ವಾಕ್ಯರಚನಾ ಸಧಾರಣೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ – ಉದಾಹರಣೆಗೆ ಅ缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺缺ಮರ್ರಪിൽ
2. ಸುಂದರ ಮುದ್ರಣ: ಮಾನ್ಯತೆ ದೊರೆತ ನಂತರ, ಪಾರ್ಸ್ ಮಾಡಿದ ಡೇಟಾವನ್ನು ಬಳಕೆದಾರನ ನಿರ್ಧಾರ ಪಕ್ಷಗಳೊಂದಿಗೆ (ಸಾಧಾರಣವಾಗಿ 2 ಅಥವಾ 4 ಸ್ಥಳಗಳು) ಮತ್ತು ಸಾಲು ವಿರಾಮ ಸಹಿತ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ರೂಪಾಂತರಿಸಲಾಗುತ್ತದೆ, ಇದು "ಸುಂದರ ಮುದ್ರಿತ" ಆವೃತ್ತಿಯಾಗಿ ಪರಿಣಮಿಸುತ್ತದೆ.

ನಿಮ್ಮ ಇನ್‌ಪುಟ್ ಮಾನ್ಯ JSON ಅಲ್ಲದಿದ್ದರೆ, ಫಾರ್ಮ್ಯಾಟರ್ ದೋಷವನ್ನು ತೋರಿಸುತ್ತದೆ ಅಥವಾ ಸಮಸ್ಯೆಯ ಸ್ಥಳ ಮತ್ತು ಸ್ವ ಭಾವವನ್ನು ಸೂಚಿಸುವ ಸಹಾಯಕ ಸಂದೇಶವನ್ನು ನೀಡುತ್ತದೆ.

ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಆಯ್ಕೆಗಳು

• ಇಂದೆಂಟೇಶನ್: ಪ್ರತಿ ಮಟ್ಟಕ್ಕೆ ಸ್ಥಳಗಳ ಸಂಖ್ಯೆ ಹೊಂದಿಸಿ (ಗರಿಷ್ಠ 8).
• ಆಬ್ಜೆಕ್ಟ್ ಕೀಲಿಗಳನ್ನು ಅಕ್ಷರಕ್ರಮದಲ್ಲಿ ಜೋಡಿಸಿ
• ಸ್ಥಳಗಳ ಬದಲು ಇಂದೆಂಟೇಶನ್‌ಗೆ ಟ್ಯಾಬ್‌ಗಳನ್ನು ಬಳಸಿ
• ASCII ಹೊರಗಿನ ಅಕ್ಷರೆಗಳನ್ನು ಯುನಿಕೋಡ್ ರೀತಿ ಎಸ್ಕೇಪ್ ಮಾಡಿ
• ಔಟ್‌ಪುಟ್ ಅನ್ನು ಮಿನಿಫೈ ಮಾಡಿ (ಒಂದು ಸಾಲಿನಲ್ಲಿ, ಸ್ಥಳವಿಲ್ಲದೆ)

ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮೂಲಕ ಪರಿಹಾರವಾದ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳು

• ಒಂದು ಸಾಲಿನ/ಮಿನಿಫೈ JSON: APIಗಳ್ ಅಥವಾ ಲಾಗ್ ಫೈಲುಗಳಿಂದ ಡೇಟಾ ಸಾಮಾನ್ಯವಾಗಿ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಕಾರ್ಯಕ್ಷಮತೆಯಿಂದ ಮಿನಿಫೈ ಆಗಿರುತ್ತವೆ, ಹೀಗಾಗಿ ಕೈಯಿಂದ ಸಂಪಾದನೆ ಕಷ್ಟ. ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಓದುಗರತೆಗೆ ಪುನಃಸ್ಥಾಪಿಸುತ್ತದೆ.
• ಅಸಮ್ಮತ ಇಂದೆಂಟೇಶನ್: ವಿವಿಧ ಮೂಲಗಳಿಂದ ನಕಲಿಸಿದ JSON ಗೋಚರಂತೆ ಟ್ಯಾಬ್, ಸ್ಥಳಗಳು ಅಥವಾ ಅಸಮ್ಮತ ಇಂದೆಂಟೇಶನ್ ಡಿಫರೆನ್ಸ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಮರುಫಾರ್ಮ್ಯಾಟ್ ವಿಭಿನ್ನತೆಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳ್ಳಿಸುತ್ತದೆ, ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಸಮ್ಮತತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ದೊಡ್ಡ ಮತ್ತು ಅಳವಡಿಸಿದ ರಚನೆಗಳು: ಆಳವಾದ ಅರೆಗಳು ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು (ಉದಾಹರಣೆಗಾಗಿ, ಸಂರಚನಾ ಕಡತಗಳು ಅಥವಾ ಸಂಕೀರ್ಣ API ಪ್ರತಿಕ್ರಿಯೆಗಳು) ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದಾಗ ಸಹಜವಾಗಿ ನಿರ್ವಹಿಸುವಂತಾಗುತ್ತವೆ, ಮತ್ತು ಬೆಂಬಲಿತ ಸಂಪಾದಕರಲ್ಲಿ ಕುರುಚುವ نماಕ ಉಂಟಾಗುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಉಪಯೋಗ: API ಪ್ರತಿಕ್ರಿಯೆಗಳ ಫಾರ್ಮ್ಯಾಟಿಂಗ್

ಮೂರನೇ पक्ष APIಗಳ (ಹಾಗೆ AWS, ಸ್ಟ್ರೈಪ್, ಗೂಗಲ್ ಕ್ಲೌಡ್) ಜೊತೆಗೆ ಸಂಯೋಜಿಸುವಾಗ, ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ವೇಗಕ್ಕಾಗಿ ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲಾಗುತ್ತದೆ. JSON ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದರಿಂದ ಮಿಸ್ ಆಗಿರುವ ಕ್ಷೇತ್ರಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು, ಅಪ್ರತ್ಯಾಶಿತ ಮೌಲ್ಯಗಳನ್ನು ಡಿಬಗ್ ಮಾಡುವುದು ಅಥವಾ ತಂಡದ ಸದಸ್ಯರೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳುವುದು ಸುಲಭವಾಗುತ್ತದೆ.

{"amount":2500,"currency":"usd","status":"succeeded","charges":[{"id":"ch_1Gq","amount":2500}]}

{
  "amount": 2500,
  "currency": "usd",
  "status": "succeeded",
  "charges": [
    {
      "id": "ch_1Gq",
      "amount": 2500
    }
  ]
}

ಈ ಉಪಕರಣವನ್ನು ಬಳಸಿ JSON ಅನ್ನು ಹೇಗೆ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವುದು

1. ನಿಮ್ಮ ಕ್ರೌಢ, ಮಿನಿಫೈ ಅಥವಾ ದುರ್ಬಳಕೆಮಾಡಿದ JSON ಅನ್ನು ಇನ್‌ಪುಟ್ ಪ್ರದೇಶದಲ್ಲಿ ಪೇಸ್ಟ್ ಅಥವಾ ಅಪ್ಲೋಡ್ ಮಾಡಿ.
2. ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಆಯ್ಕೆಗಳು (ಇಂದೆಂಟೇಶನ್ ಗಾತ್ರ, ಕೀಲಿಗಳ ಜೋಡಣೆ ಇತ್ಯಾದಿ) ಆಯ್ಕೆಮಾಡಿ.
3. ನಿಮ್ಮ ಇನ್‌ಪುಟ್ ಪ್ರಕ್ರಿಯೆಗೊಳ್ಳಲು "ಫಾರ್ಮ್ಯಾಟ್" ಕ್ಲಿಕ್ ಮಾಡಿರಿ.
4. ಶುದ್ಧ, ಓದಲು ಸುಲಭವಾದ ಔಟ್‌ಪುಟ್ ಅನ್ನು ವೀಕ್ಷಿಸಿ ಅಥವಾ ನಕಲಿಸಿ. ದೋಷಗಳು ಕಂಡುಬಂದರೆ, ವಿವರಣಾತ್ಮಕ ವಾಕ್ಯರಚನಾ ಸಂದೇಶಗಳು JSON ಸರಿಪಡಿಸಲು ನೆರವಾಗುತ್ತವೆ.

ಎಲ್ಲಾ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸುರಕ್ಷಿತವಾಗಿ ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ — ನಿಮ್ಮ ಡೇಟಾವೆಲ್ಲಾ ನಿಮ್ಮ ಡಿವೈಸ್‌ನಲ್ಲೇ ಉಳಿಯುತ್ತದೆ.

JSON ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ಗಾಗಿ ಕೋಡ್ ಉದಾಹರಣೆಗಳು

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

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

import json
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = json.dumps(json.loads(ugly), indent=2)
print(pretty)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  ugly := []byte(`{"name":"Alice","age":30,"roles":["admin","user"]}`)
  var obj interface{}
  json.Unmarshal(ugly, &obj)
  pretty, _ := json.MarshalIndent(obj, "", "  ")
  fmt.Println(string(pretty))
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) throws Exception {
    String ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    ObjectMapper mapper = new ObjectMapper();
    Object obj = mapper.readValue(ugly, Object.class);
    String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    System.out.println(pretty);
  }
}

using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    var parsed = JsonConvert.DeserializeObject(ugly);
    var pretty = JsonConvert.SerializeObject(parsed, Formatting.Indented);
    Console.WriteLine(pretty);
  }
}

<?php
$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
$obj = json_decode($ugly);
echo json_encode($obj, JSON_PRETTY_PRINT);

require 'json'
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = JSON.pretty_generate(JSON.parse(ugly))
puts pretty

echo '{"name":"Alice","age":30,"roles":["admin","user"]}' | jq .

fn main() {
  let ugly = r#"{"name":"Alice","age":30,"roles":["admin","user"]}"#;
  let value: serde_json::Value = serde_json::from_str(ugly).unwrap();
  let pretty = serde_json::to_string_pretty(&value).unwrap();
  println!("{}", pretty);
}

import com.fasterxml.jackson.databind.ObjectMapper
fun main() {
  val ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}"
  val mapper = ObjectMapper()
  val obj = mapper.readValue(ugly, Any::class.java)
  val pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
  println(pretty)
}

import Foundation
let ugly = "{\"name\":\"Alice\",\"age\":30,\"roles\":[\"admin\",\"user\"]}"
if let data = ugly.data(using: .utf8),
   let obj = try? JSONSerialization.jsonObject(with: data),
   let pretty = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted),
   let prettyString = String(data: pretty, encoding: .utf8) {
    print(prettyString)
}

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

SELECT jsonb_pretty('{"name":"Alice","age":30,"roles":["admin","user"]}'::jsonb);

SELECT JSON_PRETTY('{"name":"Alice","age":30,"roles":["admin","user"]}');

$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
$obj = $ugly | ConvertFrom-Json
$pretty = $obj | ConvertTo-Json -Depth 10
Write-Output $pretty

use JSON;
my $ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
my $obj = decode_json($ugly);
print to_json($obj, { pretty => 1 });

import 'dart:convert';
void main() {
  const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
  final obj = jsonDecode(ugly);
  final pretty = JsonEncoder.withIndent('  ').convert(obj);
  print(pretty);
}

ugly = ~s({"name":"Alice","age":30,"roles":["admin","user"]})
{:ok, obj} = Jason.decode(ugly)
pretty = Jason.encode!(obj, pretty: true)
IO.puts(pretty)

import play.api.libs.json._
object Main extends App {
  val ugly = """{"name":"Alice","age":30,"roles":["admin","user"]}"""
  val jsValue = Json.parse(ugly)
  val pretty = Json.prettyPrint(jsValue)
  println(pretty)
}