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 ਨੂੰ ਕੋਡ ਸਮੀਖਿਆ, ਦਸਤਾਵੇਜ਼ੀ ਮੌਕੇ ਜਾਂ ਸਾਂਝਾ ਕੀਤੀਆਂ ਫਾਇਲਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਸਮੀਖਿਆ, ਚਰਚਾ ਅਤੇ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ।
• ਵਰਜਨ ਕੰਟਰੋਲ: Git ਅਤੇ ਹੋਰ VCS ਟੂਲ ਫਾਰਮੈਟ ਕੀਤੇ JSON ਨਾਲ ਮਾਇਨੇਦਾਰ ਤਫ਼ਾਵਤ ਪੈਦਾ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਸਮੇਂ ਨਾਲ ਹੋਣ ਵਾਲੀਆਂ ਬਦਲਾਵਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ।
• ਅਨੁਕੂਲਤਾ: ਕਈ ਸਟਾਈਲ ਗਾਈਡ ਅਤੇ ਸੁਚਾਲਿਤ ਲਿੰਟਰ (ਜਿਵੇਂ Prettier, ESLint, ਜਾਂ jq) ਸਪੱਸ਼ਟਤਾ ਅਤੇ ਮਿਆਰਕਾਰਤਾ ਲਈ ਲਗਾਤਾਰ ਫਾਰਮੈਟਿੰਗ ਲਾਗੂ ਕਰਦੇ ਹਨ।
• ਟੂਲ ਅਨੁਕੂਲਤਾ: ਕੁਝ APIs, CLI ਅਤੇ ਸੰਪਾਦਕ ਫਾਰਮੈਟ ਕੀਤੇ ਹੋਏ ਇਨਪੁੱਟ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਮਨੁੱਖੀ ਵਰਤੋਂ ਜਾਂ ਲੌਗਿੰਗ ਆਸਾਨ ਹੋ ਸਕੇ।

JSON ਫਾਰਮੈਟਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

1. ਪਾਰਸਿੰਗ: ਫਾਰਮੈਟਰ ਪਹਿਲਾਂ ਤੁਹਾਡੀ ਡਾਟਾ ਨੂੰ ਇੱਕ ਕਠੋਰ JSON ਪਾਰਸਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਾਰਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਇਹ ਕਦਮ ਪੜਾਅ ਜਾਂ ਜਾਂਚਦਾ ਹੈ ਕਿ ਕਿ ਵਿੱਚ ਦਰੁਸਤਤਾ ਹੈ ਜਿਵੇਂ ਕਿ ਕਵੋਟ, ਅਤਿਰੀਕਤ ਕੌਮਾ ਜਾਂ ਐਸਕੇਪ ਨਾ ਕੀਤੇ ਅੱਖਰ।
2. ਸੁੰਦਰ ਪ੍ਰਿੰਟਿੰਗ: ਜਦੋਂ ਡਾਟਾ ਠੀਕ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਸਨੂੰ ਦੁਬਾਰਾ ਇੱਕ ਸਤਰ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਉਪਭੋਗਤਾ-ਤੈਅ ਕੀਤੇ ਇੰਡੈਂਟੇਸ਼ਨ (ਆਮ ਤੌਰ 'ਤੇ 2 ਜਾਂ 4 ਖਾਲੀ ਥਾਵਾਂ) ਅਤੇ ਲਾਈਨ ਬ੍ਰੇਕ ਸਮੇਤ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਨਾਲ "ਸੁੰਦਰ ਪ੍ਰਿੰਟ" ਬਣਦਾ ਹੈ।

ਜੇਕਰ ਇਨਪੁੱਟ ਠੀਕ JSON ਨਹੀਂ ਹੈ, ਤਾਂ ਫਾਰਮੈਟਰ ਕਿਸੇ ਗਲਤੀ ਦੀ ਸੂਚਨਾ ਦੇਵੇਗਾ ਜਾਂ ਮਦਦਗਾਰ ਸੁਨੇਹਾ ਦਿਖਾਏਗਾ ਜਿਸ ਵਿੱਚ ਸਮੱਸਿਆ ਦੀ ਜਗ੍ਹਾ ਅਤੇ ਕਿਸਮ ਦਰਸਾਈ ਜਾਵੇਗੀ।

ਫਾਰਮੈਟਿੰਗ ਵਿਕਲਪ

• ਇੰਡੈਂਟੇਸ਼ਨ: ਹਰ ਪੱਧਰ ਲਈ ਖਾਲੀ ਜਗ੍ਹਾ ਦੀ ਗਿਣਤੀ ਸੈੱਟ ਕਰੋ (ਅਧਿਕਤਮ 8)
• ਆਬਜੈਕਟ ਕੁੰਜੀਆਂ ਨੂੰ ਵਰਣਮਾਲਾ ਕ੍ਰਮ ਵਿੱਚ ਸਜਾਓ
• ਇੰਡੈਂਟੇਸ਼ਨ ਲਈ ਖਾਲੀ ਥਾਵਾਂ ਦੀ ਬਜਾਏ ਟੈਬ ਵਰਤੋਂ
• ਗੈਰ-ASCII ਅੱਖਰਾਂ ਨੂੰ ਯੂਨਿਕੋਡ ਵਜੋਂ ਐਸਕੇਪ ਕਰੋ
• ਆਊਟਪੁੱਟ ਨੂੰ ਮਿਨੀਫਾਈ ਕਰੋ (ਇੱਕ ਲਾਈਨ, ਬਿਨਾ ਖਾਲੀ ਥਾਵਾਂ ਦੇ)

ਫਾਰਮੈਟਿੰਗ ਨਾਲ ਹੱਲ ਹੋਣ ਵਾਲੀਆਂ ਆਮ ਸਮੱਸਿਆਵਾਂ

• ਇੱਕ-ਲਾਈਨ/ਮਿਨੀਫਾਈਡ JSON: APIs ਜਾਂ ਲੌਗ ਫਾਇਲਾਂ ਤੋਂ ਮਿੱਲਣ ਵਾਲਾ ਡਾਟਾ ਅਕਸਰ ਬੈਂਡਵਿਡਥ ਬਚਾਉਣ ਲਈ ਮਿਨੀਫਾਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਮੈਨੂਅਲ ਸੋਧ ਨੂੰ ਮੁਸ਼ਕਿਲ ਬਣਾਉਂਦਾ ਹੈ। ਫਾਰਮੈਟਿੰਗ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਵਾਪਸ ਲਿਆਉਂਦੀ ਹੈ।
• ਬੇਤਹਾਸ ਇੰਡੈਂਟੇਸ਼ਨ: ਵਿਭਿੰਨ ਸਰੋਤਾਂ ਤੋਂ ਪੇਸਟ ਕੀਤੇ JSON ਵਿੱਚ ਮਿਲੇ-ਝੁਲੇ ਟੈਬ, ਖਾਲੀ ਥਾਵਾਂ ਜਾਂ ਅਸੁਚਿੱਤ ਗਹਿਰਾਈ ਵਾਲੀ ਇੰਡੈਂਟੇਸ਼ਨ ਹੋ ਸਕਦੀ ਹੈ। ਮੁੜ-ਫਾਰਮੈਟਿੰਗ ਇਹ ਅੰਤਰਾਂ ਨੂੰ ਸਧਾਰਦਾ ਹੈ ਜੋ ਸਫਾਈ ਅਤੇ ਇੱਕਰੂਪੀਤਾ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ।
• ਵੱਡੇ/ਜਟਿਲ ਢਾਂਚੇ: ਗਹਿਰੇ ਵਿੱਢੇ ਹੋਏ ਐਰੇ ਜਾਂ ਆਬਜੈਕਟ (ਜਿਵੇਂ ਕਿ ਕਨਫਿਗਰੇਸ਼ਨ ਫਾਇਲਾਂ ਜਾਂ ਜਟਿਲ API ਜਵਾਬ) ਫਾਰਮੈਟ ਹੋਣ ਨਾਲ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਅਤੇ ਸਮਝੇ ਜਾ ਸਕਦੇ ਹਨ, ਸਮਰਥਿਤ ਸੰਪਾਦਕਾਂ ਵਿੱਚ ਸੰਕੁਚਿਤ ਵਿਹੰਗਮ ਦ੍ਰਿਸ਼ ਵੀ ਹੁੰਦਾ ਹੈ।

ਅਸਲੀ ਜ਼ਿੰਦਗੀ ਦ੍ਰਿਸ਼: API ਜਵਾਬ ਫਾਰਮੈਟਿੰਗ

ਜਦੋਂ ਤੁਸੀਂ ਤੀਜੀ-ਪੱਖੀ APIs (AWS, Stripe, ਜਾਂ Google Cloud ਵਰਗੇ) ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਜਵਾਬ ਬਹੁਤ ਵਾਰ ਤੇਜ਼ੀ ਲਈ ਸੰਕੁਚਿਤ ਹੁੰਦੇ ਹਨ। 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)
}