ਡਿਵੈਲਪਰ ਟੂਲ
JSON ਪੜ੍ਹਨਯੋਗ ਬਣਾਓ, ਛੋਟਾ ਕਰੋ ਜਾਂ ਜਾਂਚੋ
JSON ਪੇਸਟ ਕਰ ਕੇ ਪੜ੍ਹਨਯੋਗ ਬਣਾਓ, ਛੋਟਾ ਕਰੋ ਜਾਂ ਗਲਤੀ ਵੇਖੋ। ਪਾਰਸ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦਾ ਹੈ.
ਪੜ੍ਹਨਯੋਗ ਬਣਾਓ, ਇੱਕ ਕਤਾਰ ਕਰੋ ਜਾਂ ਸਿਰਫ਼ ਜਾਂਚੋ। NEXNARA ਉੱਤੇ ਨਹੀਂ ਜਾਂਦਾ.
- ਲੋਕਲ ਚੱਲਦਾ ਹੈ
- ਅੱਪਲੋਡ ਨਹੀਂ
- ਤੁਰੰਤ
- ਮੁਫ਼ਤ
ਫਾਈਲਾਂ ਇਸ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੀ ਰਹਿੰਦੀਆਂ ਹਨ। ਸਰਵਰ ਤੇ ਕੁਝ ਨਹੀਂ ਜਾਂਦਾ।
ਐਰੇ ਇੰਡੈਕਸ ਨਾਲ ਤੁਲਨਾ ਹੁੰਦੀ ਹੈ। ਸਿਰਫ਼ ਕ੍ਰਮ ਬਦਲਿਆ ਤਾਂ ਕਈ ਕਤਾਰਾਂ ਬਦਲ ਸਕਦੀਆਂ ਹਨ।
| ਕਿਸਮ | ਮਾਰਗ | ਪੁਰਾਣਾ ਮੁੱਲ | ਨਵਾਂ ਮੁੱਲ |
|---|
ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
- 01 ਡਾਟਾ ਪੇਸਟ ਕਰੋ
- 02 ਕਾਰਵਾਈ ਚਲਾਓ
- 03 ਨਤੀਜਾ ਕਾਪੀ ਕਰੋ
NEXNARA ਕਿਉਂ
-
ਨਿੱਜੀ
ਤੁਹਾਡਾ ਡਾਟਾ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ।
-
ਤੁਰੰਤ
ਨਤੀਜਾ ਤੁਰੰਤ ਦਿਖਦਾ ਹੈ।
-
ਅੱਪਲੋਡ ਨਹੀਂ
NEXNARA ਸਰਵਰ ਨੂੰ ਕੁਝ ਨਹੀਂ ਭੇਜਿਆ ਜਾਂਦਾ।
-
ਹਰ ਥਾਂ ਚੱਲਦਾ ਹੈ
ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ।
ਹੋਰ ਜਾਣੋ
JSON ਫਾਰਮੈਟਰ ਕੀ ਹੈ?
JSON ਫਾਰਮੈਟਰ ਜਾਂਚਦਾ ਹੈ ਕਿ ਟੈਕਸਟ ਸਹੀ JSON ਹੈ ਜਾਂ ਨਹੀਂ, ਫਿਰ ਇਸਨੂੰ ਇੰਡੈਂਟੇਸ਼ਨ ਨਾਲ ਜਾਂ ਇੱਕ ਲਾਈਨ ਵਾਲੀ ਸੰਖੇਪ ਸਤਰ ਵਜੋਂ ਛਾਪ ਸਕਦਾ ਹੈ। ਇਹ ਟੂਲ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JSON.parse ਅਤੇ JSON.stringify ਵਰਤਦਾ ਹੈ। ਇਹ eval ਨਹੀਂ ਵਰਤਦਾ।
ਫਾਰਮੈਟ ਅਤੇ ਮਿਨੀਫਾਈ
ਫਾਰਮੈਟਿੰਗ JSON.stringify ਪਹਿਲਾਂ ਹੀ ਕਰਦਾ ਹੈ ਉਸ ਤੋਂ ਵੱਧ ਕੁੰਜੀਆਂ, ਮੁੱਲ ਜਾਂ ਆਬਜੈਕਟ ਕ੍ਰਮ ਨਹੀਂ ਬਦਲਦੀ। ਮਿਨੀਫਾਈ ਉਹੀ JSON ਢਾਂਚਾ ਰੱਖਦਾ ਹੈ ਅਤੇ ਸਿਰਫ਼ ਬੇਲੋੜੀ ਸਪੇਸ ਅਤੇ ਲਾਈਨ ਬਰੇਕ ਹਟਾਉਂਦਾ ਹੈ।
JSON ਸੁੰਦਰ ਛਾਪੋ
ਸੁੰਦਰ ਛਪਾਈ ਲਾਈਨ ਟੁੱਟ ਅਤੇ ਇੰਡੈਂਟ ਜੋੜਦੀ ਹੈ ਤਾਂ ਅੰਦਰਲੀਆਂ ਵਸਤਾਂ ਪੜ੍ਹਨੀਆਂ ਸੌਖੀਆਂ ਹੋਣ। 2 ਸਪੇਸ, 4 ਸਪੇਸ ਜਾਂ ਟੈਬ ਚੁਣੋ। ਮੂਲ 2 ਸਪੇਸ ਹੈ।
JSON ਮਿਨੀਫਾਈ ਕਰੋ
ਮਿਨੀਫਾਈ ਵਾਧੂ ਖਾਲੀ ਥਾਂ ਅਤੇ ਲਾਈਨ ਟੁੱਟ ਹਟਾਉਂਦੀ ਹੈ; ਸਤਰ ਅੰਦਰਲੀ ਸਪੇਸ ਰਹਿੰਦੀ ਹੈ। ਡਾਟਾ ਉਹੀ ਰਹਿੰਦਾ ਹੈ।
ਗਲਤ JSON ਲੱਭੋ
ਆਮ ਸਮੱਸਿਆਵਾਂ ਹਨ ਆਖਰੀ ਕਾਮਾ, ਇਕਹਿਰੀਆਂ ਉਧਰਣਾਂ, ਟਿੱਪਣੀਆਂ ਜਾਂ ਬਿਨਾਂ ਉਧਰਣ ਕੁੰਜੀਆਂ। ਬ੍ਰਾਊਜ਼ਰ ਥਾਂ ਦੱਸੇ ਤਾਂ ਲਾਈਨ, ਕਾਲਮ ਜਾਂ ਸਥਿਤੀ ਵਿਖਾਈ ਜਾਂਦੀ ਹੈ। ਥਾਂ ਘੜੀ ਨਹੀਂ ਜਾਂਦੀ।
ਦੋ JSON ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਤੁਲਨਾ
JSON Diff ਦੋਹਾਂ ਪਾਸਿਆਂ ਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ, ਫਿਰ ਜੋੜੇ, ਹਟਾਏ, ਬਦਲੇ ਅਤੇ ਕਿਸਮ-ਬਦਲੇ ਮਾਰਗ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ। ਇੱਕੋ ਸਮੱਗਰੀ ਵਾਲਾ ਸੁੰਦਰ ਅਤੇ ਮਿਨੀਫਾਈ JSON ਬਰਾਬਰ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
ਜੋੜੇ ਅਤੇ ਹਟਾਏ ਖੇਤਰ
ਸਿਰਫ਼ JSON B ਵਿੱਚ ਮੌਜੂਦ ਮਾਰਗ ਜੋੜਿਆ ਹੈ। ਸਿਰਫ਼ JSON A ਵਿੱਚ ਮੌਜੂਦ ਹਟਾਇਆ ਹੈ। ਗੈਰਹਾਜ਼ਰ ਹੋਣਾ null ਵਰਗਾ ਨਹੀਂ।
ਬਦਲੀਆਂ ਮੁੱਲਾਂ
ਉਸੇ ਮਾਰਗ ਤੇ ਉਸੇ ਕਿਸਮ ਦੀ ਵੱਖਰੀ ਮੁੱਲ ਹੋਵੇ ਤਾਂ ਕਤਾਰ ਬਦਲਿਆ ਹੈ ਅਤੇ ਪੁਰਾਣੀ-ਨਵੀਂ ਮੁੱਲ ਵਿਖਾਉਂਦੀ ਹੈ। ਸਤਰ "100" ਅਤੇ ਨੰਬਰ 100 ਕਿਸਮ ਬਦਲੀ ਹੈ।
ਅੰਦਰਲੇ JSON ਫਰਕ
ਵਸਤਾਂ ਵਾਰ-ਵਾਰ ਤੁਲਨਾ ਹੁੰਦੀਆਂ ਹਨ। user.address.city ਅੰਦਰ ਤਬਦੀਲੀ ਉਸੇ ਮਾਰਗ ਤੇ ਦੱਸੀ ਜਾਂਦੀ ਹੈ, ਪੂਰੀ ਵਸਤ ਬਦਲੀ ਵਜੋਂ ਨਹੀਂ।
ਐਰੇ ਕਿਵੇਂ ਤੁਲਨਾ ਹੁੰਦੇ ਹਨ
ਐਰੇ ਇੰਡੈਕਸ ਨਾਲ ਤੁਲਨਾ ਹੁੰਦੇ ਹਨ: items[0], items[1] ਆਦਿ। ਕ੍ਰਮ ਬਦਲਣ ਨਾਲ ਕਈ ਫਰਕ ਆ ਸਕਦੇ ਹਨ। ਲੁਕੀ id ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ।
ਕਿਵੇਂ ਵਰਤੀਏ
ਬਾਕਸ ਵਿੱਚ JSON ਚਿਪਕਾਓ। JSON ਫਾਰਮੈਟ ਕਰੋ 2-ਸਪੇਸ ਇੰਡੈਂਟੇਸ਼ਨ ਨਾਲ ਪ੍ਰੀਟੀ-ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। JSON ਮਿਨੀਫਾਈ ਕਰੋ ਡਾਟਾ ਬਦਲੇ ਬਿਨਾਂ ਵਾਧੂ ਸਪੇਸ ਹਟਾਉਂਦਾ ਹੈ। JSON ਵੈਲੀਡੇਟ ਕਰੋ ਦੱਸਦਾ ਹੈ ਕਿ ਟੈਕਸਟ ਸਹੀ ਹੈ ਜਾਂ ਨਹੀਂ ਅਤੇ, ਜਦੋਂ ਬ੍ਰਾਊਜ਼ਰ ਦੇਵੇ, ਗਲਤੀ ਸਥਿਤੀ।
ਪਰਾਈਵੇਸੀ
ਤੁਹਾਡਾ JSON ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ। ਇਹ NEXNARA ਸਰਵਰਾਂ ’ਤੇ ਅੱਪਲੋਡ ਨਹੀਂ ਹੁੰਦਾ ਅਤੇ ਕੂਕੀਜ਼, ਲੋਕਲ ਸਟੋਰੇਜ ਜਾਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਨਹੀਂ ਸੰਭਾਲਿਆ ਜਾਂਦਾ।
ਅਕਸਰ ਪੁੱਛੇ ਸਵਾਲ
JSON ਗਲਤ ਕਿਉਂ ਹੁੰਦਾ ਹੈ?
ਆਮ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਟ੍ਰੇਲਿੰਗ ਕੌਮਾ, ਸਿੰਗਲ ਕੋਟ, ਟਿੱਪਣੀਆਂ ਜਾਂ ਬਿਨਾਂ ਕੋਟ ਵਾਲੀਆਂ ਕੁੰਜੀਆਂ ਸ਼ਾਮਲ ਹਨ। JSON.parse ਉਨ੍ਹਾਂ ਨੂੰ ਗਲਤ JSON ਵਜੋਂ ਦੱਸਦਾ ਹੈ।
ਕੀ ਫਾਰਮੈਟਿੰਗ ਮੇਰਾ JSON ਬਦਲਦੀ ਹੈ?
ਨਹੀਂ। ਫਾਰਮੈਟ ਅਤੇ ਮਿਨੀਫਾਈ ਉਹੀ ਡਾਟਾ ਰੱਖਦੇ ਹਨ। ਉਹ ਸਿਰਫ਼ ਸਪੇਸ ਬਦਲਦੇ ਹਨ। ਆਬਜੈਕਟ ਕੁੰਜੀ ਕ੍ਰਮ JSON.stringify ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ।
ਕੀ ਮੇਰਾ JSON ਅੱਪਲੋਡ ਹੁੰਦਾ ਹੈ?
ਨਹੀਂ। ਪ੍ਰੋਸੈਸਿੰਗ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਸਥਾਨਕ ਤੌਰ ’ਤੇ ਹੁੰਦੀ ਹੈ ਅਤੇ ਸਾਡੇ ਸਰਵਰਾਂ ’ਤੇ ਅੱਪਲੋਡ ਨਹੀਂ ਹੁੰਦੀ।
ਕੀ ਮੈਂ Unicode JSON ਫਾਰਮੈਟ ਕਰ ਸਕਦਾ ਹਾਂ?
ਹਾਂ। ਸਤਰਾਂ ਵਿੱਚ Unicode ਅੱਖਰ ਸਹੀ JSON ਹਨ ਅਤੇ ਫਾਰਮੈਟ ਜਾਂ ਮਿਨੀਫਾਈ ਤੋਂ ਬਾਅਦ ਉਹੀ ਰਹਿੰਦੇ ਹਨ।
ਕੀ ਇਹ ਟੂਲ JSON ਨੂੰ ਕੋਡ ਵਜੋਂ ਚਲਾਉਂਦਾ ਹੈ?
ਨਹੀਂ। ਇਹ ਸਿਰਫ਼ JSON.parse ਨਾਲ JSON ਪਾਰਸ ਕਰਦਾ ਹੈ। ਇਹ ਕਦੇ eval ਨਹੀਂ ਵਰਤਦਾ।
ਐਰੇ ਕਿਵੇਂ ਤੁਲਨਾ ਹੁੰਦੇ ਹਨ?
ਇੰਡੈਕਸ ਨਾਲ। items[0] ਦੀ ਤੁਲਨਾ items[0] ਨਾਲ ਹੁੰਦੀ ਹੈ। ਸਿਰਫ਼ ਕ੍ਰਮ ਬਦਲਿਆ ਤਾਂ ਕਈ ਕਤਾਰਾਂ ਬਦਲ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਵਰਜਨ ਵਿੱਚ ਕੁੰਜੀ-ਅਧਾਰਿਤ ਐਰੇ ਮੇਲ ਨਹੀਂ।
ਕੀ ਅੰਦਰਲਾ JSON ਤੁਲਨਾ ਕਰ ਸਕਦਾ ਹਾਂ?
ਹਾਂ। ਅੰਦਰਲੀਆਂ ਵਸਤਾਂ ਵਾਰ-ਵਾਰ ਵੇਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਤਬਦੀਲੀ user.address.city ਵਰਗੇ ਮਾਰਗ ਤੇ ਦਿਖਦੀ ਹੈ।
ਗੈਰਹਾਜ਼ਰ ਅਤੇ null ਵਿੱਚ ਕੀ ਫਰਕ ਹੈ?
ਗੈਰਹਾਜ਼ਰ ਖੇਤਰ ਹਟਾਇਆ ਜਾਂ ਜੋੜਿਆ ਹੈ। null ਅਸਲ JSON ਮੁੱਲ ਹੈ। null, "", 0 ਅਤੇ false ਇੱਕੋ ਨਹੀਂ ਮੰਨੇ ਜਾਂਦੇ।
ਕੀ ਮੇਰਾ JSON ਸਰਵਰ ਤੇ ਜਾਂਦਾ ਹੈ?
ਨਹੀਂ। ਪਾਰਸ, ਫਾਰਮੈਟ ਅਤੇ ਤੁਲਨਾ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੀ ਚੱਲਦੀ ਹੈ। ਚੁਣੀਆਂ ਫਾਈਲਾਂ ਅਪਲੋਡ ਨਹੀਂ ਹੁੰਦੀਆਂ।
JSON ਕਿੰਨਾ ਵੱਡਾ ਹੋ ਸਕਦਾ ਹੈ?
ਹਜ਼ਾਰਾਂ ਕੁੰਜੀਆਂ ਵਾਲੇ ਆਮ ਦਸਤਾਵੇਜ਼ ਠੀਕ ਚੱਲਦੇ ਹਨ। 5 MB ਤੋਂ ਉੱਪਰ ਚੇਤਾਵਨੀ ਮਿਲਦੀ ਹੈ। 15 MB ਤੋਂ ਵੱਡੇ ਰੋਕੇ ਜਾਂਦੇ ਹਨ ਤਾਂ ਬ੍ਰਾਊਜ਼ਰ ਰੁਕੇ ਨਾ।