JSON ਮਿਨੀਫਾਈ ਕਰੋ _

JSON ਮਿਨੀਫਿਕੇਸ਼ਨ ਕੀ ਹੈ?

JSON (JavaScript Object Notation) RFC 8259 ਅਤੇ ECMA-404 ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਇੱਕ ਹਲਕਾ, ਟੈਕਸਟ-ਆਧਾਰਤ ਡੇਟਾ-ਇੰਟਰਚੇਂਜ ਫਾਰਮੈਟ ਹੈ। ਮਿਨੀਫਿਕੇਸ਼ਨ ਹਰ ਸਪੇਸ, ਟੈਬ, ਅਤੇ ਨਿਊਲਾਈਨ ਜੋ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲ ਤੋਂ ਬਾਹਰ ਬੈਠਦੀ ਹੈ ਹਟਾਉਂਦੀ ਹੈ — ਮੁੱਲ ਬਾਈਟ-ਦਰ-ਬਾਈਟ ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੇ ਹਨ। ਆਉਟਪੁੱਟ ਇਨਪੁੱਟ ਵਾਂਗੂ ਬਿਲਕੁਲ ਉਹੀ ਮੁੱਲ ਤੇ ਪਾਰਸ ਹੁੰਦੀ ਹੈ।

JSON ਮਿਨੀਫਿਕੇਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

ਤੁਹਾਡਾ ਇਨਪੁੱਟ ਬਿਲਟ-ਇਨ JSON.parse ਅਤੇ JSON.stringify ਫੰਕਸ਼ਨਾਂ ਵਰਤ ਕੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਪ੍ਰੋਸੈੱਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉੱਚ-ਪੱਧਰੀ ਕਦਮ:

1. ਤੁਹਾਡਾ ਇਨਪੁੱਟ ਟੈਕਸਟਏਰੀਆ ਤੋਂ ਜਿਉਂ-ਦਾ-ਤਿਉਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ — ਤੁਹਾਡੇ ਪੇਸਟ ਕੀਤੇ ਹਰ ਬਾਈਟ ਲੋਕਲੀ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖੇ ਜਾਂਦੇ ਹਨ।
2. ਬ੍ਰਾਊਜ਼ਰ ਇਸਨੂੰ JSON.parse ਨਾਲ ਪਾਰਸ ਕਰਦਾ ਹੈ। ਜੇ ਇਨਪੁੱਟ ਵੈਧ JSON ਨਹੀਂ ਹੈ, ਪਾਰਸਰ SyntaxError ਸੁੱਟਦਾ ਹੈ ਜੋ ਜਿਉਂ-ਦੀ-ਤਿਉਂ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ — ਤੁਹਾਡਾ ਟੈਕਸਟ ਕਦੇ ਪੇਜ ਨਹੀਂ ਛੱਡਦਾ।
3. ਜਦੋਂ ਪਾਰਸਿੰਗ ਸਫਲ ਹੋਵੇ, ਪਾਰਸ ਕੀਤਾ ਮੁੱਲ JSON.stringify(value) ਨਾਲ ਮੁੜ-ਛੱਡਿਆ ਜਾਂਦਾ ਹੈ — ਬਿਨਾਂ ਇੰਡੈਂਟ ਆਰਗੂਮੈਂਟ ਦੇ।
4. ਅਸਲ ਅਤੇ ਮਿਨੀਫਾਈਡ ਟੈਕਸਟ ਦੋਵਾਂ ਦੀ ਬਾਈਟ ਲੰਬਾਈ new TextEncoder().encode(...).byteLength ਨਾਲ ਗਿਣੀ ਜਾਂਦੀ ਹੈ।
5. ਆਉਟਪੁੱਟ ਰੀਡਓਨਲੀ ਟੈਕਸਟਏਰੀਆ ਵਿੱਚ ਲਿਖੀ ਜਾਂਦੀ ਹੈ, ਮੈਟ੍ਰਿਕ ਸਟ੍ਰਿਪ ਪ੍ਰਤੀਸ਼ਤ ਬੱਚਤ ਨਾਲ ਬਾਈਟ ਡੈਲਟਾ ਰਿਪੋਰਟ ਕਰਦੀ ਹੈ, ਅਤੇ ਡਾਊਨਲੋਡ ਬਟਨ ਨਤੀਜਾ .min.json ਫਾਈਲ ਵਜੋਂ ਪੈਕੇਜ ਕਰਦਾ ਹੈ।

ਇਸ ਟੂਲ ਨਾਲ JSON ਮਿਨੀਫਾਈ ਕਿਉਂ ਕਰੋ?

• ਪ੍ਰਾਈਵੇਸੀ: ਹਰ ਪਾਰਸ, ਮਿਨੀਫਾਈ, ਅਤੇ ਮੈਟ੍ਰਿਕ ਪਾਸ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। JSON ਕਦੇ ਸਾਡੇ ਸਰਵਰਾਂ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦੀ — ਕੋਈ ਅਪਲੋਡ ਨਹੀਂ, ਕੋਈ ਟੈਲੀਮੈਟਰੀ ਨਹੀਂ, ਕੋਈ ਖਾਤਾ ਨਹੀਂ।
• ਅਸਲ ਬਾਈਟ ਨੰਬਰ: ਅਸਲ ਆਕਾਰ, ਮਿਨੀਫਾਈਡ ਆਕਾਰ, ਅਤੇ ਬੱਚਤ TextEncoder ਨਾਲ ਗਿਣੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ ਜੋ ਤੁਸੀਂ ਅਸਲ UTF-8 ਬਾਈਟ ਡੈਲਟਾ ਦੇਖੋ।
• ਜ਼ੀਰੋ ਡੇਟਾ ਨੁਕਸਾਨ: ਮਿਨੀਫਿਕੇਸ਼ਨ ਸਿਰਫ਼ ਸੁੰਦਰਤਾਈ ਹੈ — ਹਰ ਮੁੱਲ ਇੱਕੋ JSON ਟ੍ਰੀ ਤੇ ਪਾਰਸ ਹੁੰਦਾ ਹੈ।
• ਤੇਜ਼: ਸ਼ੁੱਧ JSON.parse + JSON.stringify ਆਮ ਕਲਿੱਪਬੋਰਡ-ਆਕਾਰ ਪੇਲੋਡ ਤੁਰੰਤ ਸੰਭਾਲਦੇ ਹਨ।

JSON ਮਿਨੀਫਿਕੇਸ਼ਨ ਦੀਆਂ ਆਮ ਵਰਤੋਂ ਕੀ ਹਨ?

JSON ਤੋਂ ਗੈਰ-ਮਹੱਤਵਪੂਰਨ ਵ੍ਹਾਈਟਸਪੇਸ ਹਟਾਉਣਾ ਵੈੱਬ ਡਿਵੈਲਪਮੈਂਟ, ਡੇਟਾ ਇੰਜੀਨੀਅਰਿੰਗ, ਅਤੇ ਏਮਬੈੱਡਡ ਸਿਸਟਮਾਂ ਵਿੱਚ ਹਰ ਥਾਂ ਦਿਖਦਾ ਹੈ:

• API ਪੇਲੋਡ ਘਟਾਉਣਾ: ਮੀਟਰਡ API ਗੇਟਵੇ, ਭੁਗਤਾਨਯੋਗ ਐਗਰੈੱਸ ਲਿੰਕ, ਜਾਂ ਸੈਟੇਲਾਈਟ ਲਿੰਕ ਪਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਬੇਨਤੀ ਅਤੇ ਜਵਾਬ ਬਾਡੀਆਂ ਛੋਟੀਆਂ ਕਰੋ।
• HTML ਵਿੱਚ ਏਮਬੈੱਡਿੰਗ: JSON ਬਲਾਬ ਨੂੰ data-* ਐਟ੍ਰੀਬਿਊਟ ਜਾਂ <script type="application/json"> ਟੈਗ ਵਿੱਚ ਭਰੋ।
• ਛੋਟੀ localStorage: ਪ੍ਰੀਟੀ-ਪ੍ਰਿੰਟ ਕੀਤੀ JSON ਦੀ ਬਜਾਏ ਮਿਨੀਫਾਈਡ JSON ਲਿਖ ਕੇ localStorage / IndexedDB ਕੋਟਾ ਵਰਤੋਂ ਘਟਾਓ, ਜੋ ਖਾਸ ਤੌਰ ਤੇ ਸਖ਼ਤ ਪ੍ਰਤੀ-ਮੂਲ ਸਟੋਰੇਜ ਸੀਮਾਵਾਂ ਵਾਲੇ ਮੋਬਾਈਲ ਬ੍ਰਾਊਜ਼ਰਾਂ ਉੱਤੇ ਕੀਮਤੀ ਹੈ।

JSON ਮਿਨੀਫਿਕੇਸ਼ਨ ਉਦਾਹਰਣ ਕਿਵੇਂ ਦਿਖਦੀ ਹੈ?

ਇੱਕ 1.2 KB ਪ੍ਰੀਟੀ-ਪ੍ਰਿੰਟ ਕੀਤੀ ਕਾਨਫਿਗਰੇਸ਼ਨ ਫਾਈਲ (ਦੋ-ਸਪੇਸ ਇੰਡੈਂਟਾਂ ਨਾਲ ਲਗਭਗ 1,225 ਬਾਈਟ) ਪੇਸਟ ਕਰਕੇ ਅਤੇ Minify ਦਬਾਉਣ ਨਾਲ ਆਮ ਤੌਰ ਤੇ ਇਹ 0.4 KB ਤੋਂ ਘੱਟ ਤੱਕ ਸੁੰਗੜ ਜਾਂਦੀ ਹੈ — 66% ਬੱਚਤ — ਹਰ ਕੁੰਜੀ ਅਤੇ ਮੁੱਲ ਬਿਲਕੁਲ ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੇ ਹੋਏ। ਡਾਊਨਲੋਡਯੋਗ output.min.json ਫਾਈਲ ਉਸ ਨਾਲ ਬਾਈਟ-ਇਡੈਂਟੀਕਲ ਹੈ ਜੋ ਇੱਕ HTTP ਸਰਵਰ Content-Type: application/json ਨਾਲ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਫਾਰਮੈਟਿੰਗ ਮਿਡਲਵੇਅਰ ਦੇ ਛੱਡੇਗਾ।

ਕੀ ਇਹ ਮੇਰੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ?

ਹਾਂ। ਮਿਨੀਫਾਈ ਪਾਈਪਲਾਈਨ ਸ਼ੁੱਧ JSON.parse + JSON.stringify ਹੈ ਜੋ ਬ੍ਰਾਊਜ਼ਰ ਟੈਬ ਵਿੱਚ ਚੱਲਦੀ ਹੈ। ਕੁਝ ਵੀ ਅਪਲੋਡ ਨਹੀਂ ਹੁੰਦਾ, ਕੋਈ ਸਰਵਿਸ ਵਰਕਰ ਤੁਹਾਡਾ ਇਨਪੁੱਟ ਪ੍ਰੌਕਸੀ ਨਹੀਂ ਕਰਦਾ, ਅਤੇ ਪੇਜ ਮਿਨੀਫਾਈ ਕਦਮ ਲਈ ਜ਼ੀਰੋ ਨੈੱਟਵਰਕ ਬੇਨਤੀਆਂ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੀ JSON ਕਦੇ Ultim8Soft ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦੀ।

JSON ਮਿਨੀਫਾਈ ਕਿਉਂ ਕਰੋ?

ਮਿਨੀਫਾਈਡ JSON ਪ੍ਰੀਟੀ-ਪ੍ਰਿੰਟ ਕੀਤੇ ਸਰੋਤ ਵਾਂਗ ਬਿਲਕੁਲ ਉਹੀ ਮੁੱਲ ਤੇ ਪਾਰਸ ਹੁੰਦੀ ਹੈ ਪਰ ਤਾਰ ਉੱਤੇ ਅਤੇ ਸਟੋਰੇਜ ਵਿੱਚ ਛੋਟੀ ਹੁੰਦੀ ਹੈ। ਛੋਟੇ ਪੇਲੋਡ ਦਾ ਮਤਲਬ ਹੈ ਘੱਟ CDN ਐਗਰੈੱਸ ਬਿੱਲ, ਤੇਜ਼ ਮੋਬਾਈਲ ਡਾਊਨਲੋਡ, ਸਰਵਿਸ ਵਰਕਰਾਂ ਦੇ ਅੰਦਰ ਘੱਟ ਮੈਮੋਰੀ ਦਬਾਅ, ਅਤੇ JWT ਪੇਲੋਡ, ਏਮਬੈੱਡ ਕੀਤੀਆਂ HTML data-* ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਅਤੇ localStorage ਕੋਟਾ ਵਰਗੇ ਨਿਸ਼ਚਿਤ-ਆਕਾਰ ਲਿਫ਼ਾਫ਼ਿਆਂ ਵਿੱਚ ਤੰਗ ਫਿਟ। ਉੱਚ-ਆਇਤਨ ਵਾਲੀਆਂ API ਲਈ ਬਾਈਟ ਬੱਚਤ ਜੋੜਦੀ ਜਾਂਦੀ ਹੈ — 1 GB/ਦਿਨ ਵਾਲੇ ਐਂਡਪੁਆਇੰਟ ਉੱਤੇ 30% ਦੀ ਕਮੀ ਪ੍ਰਤੀ ਮਹੀਨਾ ਲਗਭਗ 9 GB ਬਚਾਉਂਦੀ ਹੈ।

ਕੀ ਮਿਨੀਫਿਕੇਸ਼ਨ ਡੇਟਾ ਗੁਆਉਂਦੀ ਹੈ?

ਨਹੀਂ। JSON ਮਿਨੀਫਿਕੇਸ਼ਨ ਸਿਰਫ਼ ਉਹ ਵ੍ਹਾਈਟਸਪੇਸ ਹਟਾਉਂਦੀ ਹੈ ਜੋ ਸਟ੍ਰਿੰਗ ਲਿਟਰਲਾਂ ਤੋਂ ਬਾਹਰ ਬੈਠਦੀ ਹੈ — ਸਪੇਸ, ਟੈਬ, ਅਤੇ ਨਿਊਲਾਈਨਾਂ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਪੈੱਕ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਬੇਅਰਥ ਵਜੋਂ ਵਰਗੀਕ੍ਰਿਤ ਕਰਦਾ ਹੈ। ਹਰ ਕੁੰਜੀ, ਮੁੱਲ, ਨੰਬਰ, ਅਸਕੇਪ ਕ੍ਰਮ, ਅਤੇ ਸਟ੍ਰਿੰਗ ਅੱਖਰ ਬਾਈਟ-ਦਰ-ਬਾਈਟ ਸੁਰੱਖਿਅਤ ਰਹਿੰਦਾ ਹੈ। ਆਉਟਪੁੱਟ ਇੱਕ ਅਜਿਹੇ ਮੁੱਲ ਤੇ ਪਾਰਸ ਹੁੰਦੀ ਹੈ ਜੋ ਇਨਪੁੱਟ ਨਾਲ deepEqual ਹੁੰਦਾ ਹੈ। ਸਿਰਫ਼ ਸੁੰਦਰਤਾਈ ਇੰਡੈਂਟੇਸ਼ਨ ਹੀ ਉਹ ਚੀਜ਼ ਹੈ ਜੋ ਅਲੋਪ ਹੁੰਦੀ ਹੈ।

ਫਾਰਮੈਟਰ ਅਤੇ ਮਿਨੀਫਾਇਰ ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?

ਸਹਿਯੋਗੀ JSON Formatter ਦੂਜੀ ਦਿਸ਼ਾ ਵਿੱਚ ਜਾਂਦਾ ਹੈ: ਇਹ ਵ੍ਹਾਈਟਸਪੇਸ ਫੈਲਾਉਂਦਾ ਹੈ ਤਾਂ ਜੋ ਮਨੁੱਖ ਨੈਸਟਡ ਢਾਂਚੇ ਪੜ੍ਹ ਸਕਣ। Minifier ਉਹ ਵ੍ਹਾਈਟਸਪੇਸ ਵਾਪਸ ਹਟਾਉਂਦਾ ਹੈ। ਦੋਵੇਂ ਟੂਲ ਉਲਟ ਹਨ — Formatter → Minifier ਰਾਹੀਂ JSON ਦਸਤਾਵੇਜ਼ ਦਾ ਰਾਊਂਡ-ਟ੍ਰਿਪ ਕਰਨ ਨਾਲ ਉਹੀ ਬਾਈਟ-ਸਟ੍ਰਿੰਗ ਮਿਲਦੀ ਹੈ ਜੋ ਤੁਸੀਂ ਮਿਨੀਫਾਇਰ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤੀ ਸੀ।

ਇਹ JSON ਮਿਨੀਫਾਇਰ ਉਸੇ ਪਾਰਸਰ ਵਰਤਦਾ ਹੈ ਜੋ ਤੁਹਾਡਾ Node.js, Deno, ਜਾਂ ਬ੍ਰਾਊਜ਼ਰ ਰਨਟਾਈਮ ਵਰਤਦਾ ਹੈ। ਉੱਪਰ ਕੋਈ ਵੀ JSON ਪੇਸਟ ਕਰੋ, ਆਉਟਪੁੱਟ ਕਾਪੀ ਕਰੋ, ਜਾਂ .min.json ਵਜੋਂ ਡਾਊਨਲੋਡ ਕਰੋ।