ਇਸ ਟੂਲ ਬਾਰੇ
JSON ਫਾਰਮੈਟਿੰਗ (ਅਕਸਰ ਪ੍ਰੈਟੀ-ਪ੍ਰਿੰਟਿੰਗ ਜਾਂ ਬਿਊਟੀਫਿਕੇਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਸੰਕੁਚਿਤ JSON ਲੈਂਦਾ ਹੈ ਅਤੇ ਮਨੁੱਖੀ ਪਾਠਕਾਂ ਲਈ ਬਣਤਰ ਨੂੰ ਦ੍ਰਿਸ਼ਮਾਨ ਬਣਾਉਣ ਲਈ - ਲਾਈਨ ਬ੍ਰੇਕ, ਇੰਡੈਂਟੇਸ਼ਨ, ਇਕਸਾਰ ਸਪੇਸਿੰਗ - ਨੂੰ ਜੋੜਦਾ ਹੈ। ਸੰਖੇਪ JSON ਪ੍ਰਸਾਰਣ ਲਈ ਸਹੀ ਫਾਰਮੈਟ ਹੈ: ਇਹ ਤਾਰ ਅਤੇ ਸਟੋਰੇਜ ਉੱਤੇ ਬਾਈਟਾਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ। ਫਾਰਮੈਟ ਕੀਤਾ JSON ਨਿਰੀਖਣ ਲਈ ਸਹੀ ਫਾਰਮੈਟ ਹੈ: ਇੰਡੈਂਟਡ ਦਰਜਾਬੰਦੀ ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ ਨੇਸਟਡ ਢਾਂਚੇ ਨੂੰ ਪ੍ਰਗਟ ਕਰਦੀ ਹੈ, ਅੰਤਰਾਂ ਨੂੰ ਅਰਥਪੂਰਨ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਮਾਨਸਿਕ ਤੌਰ 'ਤੇ ਪਾਰਸ ਕੀਤੇ ਬਿਨਾਂ ਖਾਸ ਖੇਤਰਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦਿੰਦਾ ਹੈ।
ਇਹ ਫਾਰਮੈਟਰ ਇਹ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ JSON ਦੇ ਤੌਰ 'ਤੇ ਇਨਪੁਟ ਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਵੈਧ ਹੈ, ਫਿਰ ਇਸ ਨੂੰ ਇਕਸਾਰ ਇੰਡੈਂਟੇਸ਼ਨ ਦੇ ਨਾਲ ਮੁੜ-ਪ੍ਰਸਾਰਿਤ ਕਰਦਾ ਹੈ। ਅਵੈਧ ਇਨਪੁਟ ਸੰਟੈਕਸ ਸਮੱਸਿਆ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੀ ਇੱਕ ਗਲਤੀ ਪੈਦਾ ਕਰਦੀ ਹੈ। ਵੈਧ ਇਨਪੁਟ ਨੂੰ ਰੀਫਾਰਮੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਭਾਵੇਂ ਸਰੋਤ ਕਿੰਨਾ ਵੀ ਸੰਖੇਪ ਜਾਂ ਗੜਬੜ ਵਾਲਾ ਸੀ। ਸਭ ਤੋਂ ਆਮ JavaScript ਕਨਵੈਨਸ਼ਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ, ਦੋ ਸਪੇਸ ਲਈ ਡਿਫੌਲਟ ਇੰਡੈਂਟੇਸ਼ਨ।
ਫਾਰਮੈਟਰ ਮਿਨੀਫਿਕੇਸ਼ਨ (ਉਲਟਾ ਕਾਰਵਾਈ) ਦੀ ਵੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਜੋ ਸਭ ਤੋਂ ਛੋਟੀ ਵੈਧ JSON ਪੈਦਾ ਕਰਨ ਲਈ ਸਾਰੀਆਂ ਬੇਲੋੜੀ ਖਾਲੀ ਥਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ। ਮਿੰਨੀਫਾਈਡ ਆਉਟਪੁੱਟ ਉਤਪਾਦਨ ਪ੍ਰਸਾਰਣ ਲਈ ਉਪਯੋਗੀ ਹੈ; ਫਾਰਮੈਟ ਕੀਤੀ ਆਉਟਪੁੱਟ ਵਿਕਾਸ ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ ਲਾਭਦਾਇਕ ਹੈ।
JSON ਨੂੰ ਫਾਰਮੈਟ ਕਿਉਂ ਕਰੋ
ਬਿਨਾਂ ਇੰਡੈਂਟੇਸ਼ਨ ਦੇ ਡੂੰਘੇ ਨੇਸਟਡ JSON ਨੂੰ ਪੜ੍ਹਨਾ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਅਸੰਭਵ ਹੈ — ਬਣਤਰ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਮੌਜੂਦ ਹੈ ਪਰ ਅਦਿੱਖ ਹੈ। ਇੱਥੋਂ ਤੱਕ ਕਿ ਔਸਤਨ ਗੁੰਝਲਦਾਰ JSON ਨੂੰ ਫਾਰਮੈਟਿੰਗ ਤੋਂ ਬਹੁਤ ਲਾਭ ਮਿਲਦਾ ਹੈ। ਕੋਡ ਸਮੀਖਿਅਕ, API ਡੀਬੱਗਰ, ਅਤੇ ਕਿਸੇ ਵੀ ਵਿਅਕਤੀ ਨੂੰ ਡੇਟਾ ਪੇਲੋਡ ਨੂੰ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਵਾਲੇ ਨੂੰ ਇਹ ਦੇਖਣ ਲਈ JSON ਫਾਰਮੈਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਅਸਲ ਵਿੱਚ ਉੱਥੇ ਕੀ ਹੈ।
ਫਾਰਮੈਟਿੰਗ ਵੀ ਗਲਤੀਆਂ ਫੜਦੀ ਹੈ। ਜੇਕਰ JSON ਫਾਰਮੈਟਿੰਗ ਦੌਰਾਨ ਪਾਰਸ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਗਲਤੀ ਸੁਨੇਹਾ ਸਿੰਟੈਕਸ ਸਮੱਸਿਆ ਦੀ ਸਹੀ ਸਥਿਤੀ ਦੀ ਪਛਾਣ ਕਰਦਾ ਹੈ — ਅਕਸਰ ਇੱਕ ਗੁੰਮ ਕੌਮਾ, ਇੱਕ ਅਣਕੋਟਿਡ ਕੁੰਜੀ, ਜਾਂ ਇੱਕ ਅਵਾਰਾ ਟ੍ਰੇਲਿੰਗ ਕਾਮੇ ਜਿਸਨੂੰ ਉਤਪਾਦਨ ਸਿਸਟਮ ਨੇ ਫਲੈਗ ਨਹੀਂ ਕੀਤਾ ਸੀ। ਇੱਕ ਫਾਰਮੈਟਰ ਸਭ ਤੋਂ ਸਰਲ JSON ਪ੍ਰਮਾਣਕ ਉਪਲਬਧ ਹੈ।
ਤਕਨੀਕੀ ਵੇਰਵੇ
ਫਾਰਮੈਟਰ JSON.parse ਅਤੇ JSON.stringify ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਹਰ JavaScript ਰਨਟਾਈਮ ਜਹਾਜ਼ਾਂ ਲਈ ਇੱਕੋ ਜੋੜਾ। ਪਾਰਸਿੰਗ RFC 8259 (ਮੌਜੂਦਾ JSON ਸਪੇਕ) ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ, ਸਖਤ JSON ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਪਰ JavaScript ਆਬਜੈਕਟ ਲਿਟਰਲ, ਟਿੱਪਣੀਆਂ, ਟ੍ਰੇਲਿੰਗ ਕਾਮੇ, ਅਤੇ ਹੋਰ JSON5 ਐਕਸਟੈਂਸ਼ਨਾਂ ਨੂੰ ਰੱਦ ਕਰਦਾ ਹੈ।
JSON.stringify ਇੱਕ ਇੰਡੈਂਟ ਆਰਗੂਮੈਂਟ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ: ਇੱਕ ਨੰਬਰ (ਸਪੇਸ) ਜਾਂ ਸਤਰ (ਕਸਟਮ ਇੰਡੈਂਟ ਅੱਖਰ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਟੈਬ)। ਫਾਰਮੇਟਰ ਦੋਵਾਂ ਵਿਕਲਪਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ। ਆਉਟਪੁੱਟ ਨੂੰ ਵਸਤੂਆਂ ਲਈ ਸਰੋਤ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ (ਕਿਉਂਕਿ ES2015 ਨੇ ਸਾਰੇ ਪ੍ਰਮੁੱਖ ਇੰਜਣਾਂ ਵਿੱਚ ਸੰਪੱਤੀ ਸੰਮਿਲਨ ਆਰਡਰ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਹੈ)।
ਕਿਨਾਰੇ ਦੇ ਕੇਸ: ਨੰਬਰ ਤੋਂ ਪਰੇ ਵੱਡੀਆਂ ਸੰਖਿਆਵਾਂ। ਪਾਰਸ ਕੀਤੇ ਜਾਣ 'ਤੇ MAX_SAFE_INTEGER ਸ਼ੁੱਧਤਾ ਗੁਆ ਦਿੰਦੇ ਹਨ (ਇੱਕ ਜਾਣੀ ਜਾਂਦੀ JSON ਸੀਮਾ; 2^53 ਤੋਂ ਵੱਧ ਆਈਡੀ ਲਈ ਸਟ੍ਰਿੰਗ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ)। ਸਟ੍ਰਿੰਗਸ ਵਿੱਚ ਯੂਨੀਕੋਡ ਐਸਕੇਪ ਨੂੰ ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਗਿਆ ਹੈ। ਹਰ ਲਾਈਨ ਤੋਂ ਪਿੱਛੇ ਵਾਲੀ ਖਾਲੀ ਥਾਂ ਹਟਾਈ ਜਾਂਦੀ ਹੈ।
ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ
- ਇਹ ਟੂਲ ਕਿਸ ਕਿਸਮ ਦੀਆਂ JSON ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ?
- ਇਹ ਟੂਲ RFC 8259 JSON ਨਿਰਧਾਰਨ ਦੇ ਅਨੁਸਾਰ ਗੁੰਮ ਹੋਏ ਕਾਮੇ, ਬੇਮੇਲ ਬਰੈਕਟ/ਬ੍ਰੇਸ, ਅਵੈਧ ਸਟ੍ਰਿੰਗ ਐਸਕੇਪਿੰਗ, ਟ੍ਰੇਲਿੰਗ ਕਾਮੇ, ਸਿੰਗਲ-ਕੋਟੇਡ ਸਤਰ, ਅਤੇ ਹੋਰ ਸੰਟੈਕਸ ਉਲੰਘਣਾਵਾਂ ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ।
- ਕੀ ਇਹ ਬਹੁਤ ਵੱਡੀਆਂ JSON ਫਾਈਲਾਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ?
- ਹਾਂ। ਫਾਰਮੈਟਰ ਮੂਲ JavaScript ਪਾਰਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JSON ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਇਹ ਕਈ ਮੈਗਾਬਾਈਟ ਤੱਕ ਦੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਹੈਂਡਲ ਕਰਦਾ ਹੈ। ਬਹੁਤ ਵੱਡੀਆਂ ਫਾਈਲਾਂ (50MB+) ਲਈ, ਪ੍ਰੋਸੈਸਿੰਗ ਸਮਾਂ ਤੁਹਾਡੀ ਡਿਵਾਈਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।
- ਕੀ ਇਹ ਟਿੱਪਣੀਆਂ (JSONC) ਨਾਲ JSON ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ?
- ਸਟੈਂਡਰਡ JSON ਟਿੱਪਣੀਆਂ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਇਨਪੁਟ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਹਨ, ਤਾਂ ਪ੍ਰਮਾਣਕ ਉਹਨਾਂ ਨੂੰ ਤਰੁੱਟੀਆਂ ਵਜੋਂ ਫਲੈਗ ਕਰੇਗਾ। JSONC ਸਹਾਇਤਾ ਲਈ, ਫਾਰਮੈਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਟਿੱਪਣੀਆਂ ਨੂੰ ਹਟਾਓ।
- ਕੀ ਫਾਰਮੈਟਿੰਗ ਮੇਰੇ ਡੇਟਾ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲ ਦੇਵੇਗੀ?
- ਨਹੀਂ। ਫਾਰਮੈਟਿੰਗ ਸਿਰਫ਼ ਵ੍ਹਾਈਟਸਪੇਸ ਅਤੇ ਇੰਡੈਂਟੇਸ਼ਨ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਦੀ ਹੈ — ਤੁਹਾਡੀਆਂ ਡਾਟਾ ਕਿਸਮਾਂ, ਮੁੱਲ, ਅਤੇ ਬਣਤਰ ਬਿਲਕੁਲ ਉਹੀ ਰਹਿੰਦੇ ਹਨ।
- ਕੀ JSON5 ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਮਰਥਿਤ ਹਨ (ਟਿੱਪਣੀਆਂ, ਪਿਛਲਾ ਕਾਮੇ)?
- ਨਹੀਂ। ਫਾਰਮੇਟਰ RFC 8259 ਦੀ ਸਖਤੀ ਨਾਲ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। JSON5 ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪਾਰਸ ਗਲਤੀਆਂ ਦਾ ਕਾਰਨ ਬਣਦੀਆਂ ਹਨ। JSON5 ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਪਹਿਲਾਂ ਇੱਕ JSON5 ਪਾਰਸਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਿਆਰੀ JSON ਵਿੱਚ ਬਦਲੋ।
- ਕੀ ਮੇਰਾ JSON ਸਰਵਰ 'ਤੇ ਅੱਪਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ?
- ਨਹੀਂ। ਪਾਰਸਿੰਗ ਅਤੇ ਫਾਰਮੈਟਿੰਗ ਬਿਲਟ-ਇਨ JSON ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦੀ ਹੈ।
- ਕੀ ਵੱਡੀ ਗਿਣਤੀ ਸ਼ੁੱਧਤਾ ਗੁਆ ਦੇਵੇਗੀ?
- JavaScript ਸੰਖਿਆਵਾਂ ਨੂੰ 64-ਬਿੱਟ ਫਲੋਟਸ ਵਜੋਂ ਦਰਸਾਉਂਦਾ ਹੈ, ਇਸਲਈ 2^53 (ਲਗਭਗ 9 ਕਵਾਡ੍ਰਿਲੀਅਨ) ਤੋਂ ਉੱਪਰ ਦੇ ਪੂਰਨ ਅੰਕ ਸ਼ੁੱਧਤਾ ਗੁਆ ਦਿੰਦੇ ਹਨ। ID ਜਾਂ ਹੋਰ ਵੱਡੇ ਪੂਰਨ ਅੰਕ ਮੁੱਲਾਂ ਲਈ, ਉਹਨਾਂ ਨੂੰ JSON ਵਿੱਚ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕਰੋ।
- ਕੀ ਮੈਂ ਵਰਣਮਾਲਾ ਅਨੁਸਾਰ ਕੁੰਜੀਆਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰ ਸਕਦਾ ਹਾਂ?
- JSON.stringify ਕੁੰਜੀਆਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਸਤਰਬੱਧ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੁੰਜੀਆਂ ਨੂੰ ਵਰਣਮਾਲਾ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵੱਖਰਾ ਲੜੀਬੱਧ ਕਦਮ (ਜਾਂ ਛਾਂਟੀ ਸਮਰਥਨ ਵਾਲਾ ਇੱਕ ਫਾਰਮੈਟਰ) ਦੀ ਵਰਤੋਂ ਕਰੋ।