JSON ਤੋਂ CSV ਪਰਿਵਰਤਨ: ਬਰਾਊਜ਼ਰ-ਅਧਾਰਿਤ ਫਲੈਟਨਿੰਗ ਟੂਲ
ਇਹ ਪੰਨਾ ਤੁਹਾਨੂੰ ਇੱਕ JSON ਫ਼ਾਈਲ (ਜਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਖਿੱਚ ਕੇ ਸਿੱਧਾ ਛੱਡ ਸਕਦੇ ਹੋ) ਨੂੰ CSV ਫ਼ਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦਾ ਹੈ। ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਤੁਹਾਡੇ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਹੀ ਹੁੰਦੀ ਹੈ – ਕੋਈ ਵੀ ਡਾਟਾ ਕਿਸੇ ਸਰਵਰ 'ਤੇ ਅੱਪਲੋਡ ਨਹੀਂ ਹੁੰਦਾ। ਤੁਸੀਂ CSV ਲਈ ਡਿਲੀਮੀਟਰ (ਕੌਮਾ, ਸੈਮੀ-ਕੌਲਨ, ਜਾਂ ਟੈਬ) ਚੁਣ ਸਕਦੇ ਹੋ, ਨਤੀਜੇ ਦੀ ਸਾਰਣੀ ਦਾ ਪ੍ਰੀਵਿਊ ਦੇਖ ਸਕਦੇ ਹੋ, ਅਤੇ ਪਰਿਵਰਤਿਤ ਫ਼ਾਈਲ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਟੂਲ JSON ਦੀਆਂ ਨੇਸਟਡ ਬਣਤਰਾਂ, ਕਿਸਮਾਂ (ਨੰਬਰ, ਬੂਲੀਅਨ, null) ਅਤੇ ਆਬਜੈਕਟਸ ਨੂੰ ਇੱਕ ਫਲੈਟ, ਅਕਿਸਮੀ CSV ਸਾਰਣੀ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਹੇਠਾਂ ਅਸੀਂ ਇਸ ਪਰਿਵਰਤਨ ਦੇ ਤਕਨੀਕੀ ਪਹਿਲੂਆਂ, ਨਿਯਮਾਂ ਅਤੇ ਸੀਮਾਵਾਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ।
JSON ਅਤੇ CSV ਵਿਚਕਾਰ ਬੁਨਿਆਦੀ ਫ਼ਰਕ
JSON (JavaScript Object Notation) ਇੱਕ ਦਰਖ਼ਤ-ਵਰਗੀ, ਦਰਜੇਬੰਦ ਬਣਤਰ ਵਾਲਾ ਡਾਟਾ ਫ਼ਾਰਮੈਟ ਹੈ। ਇਸ ਵਿੱਚ ਆਬਜੈਕਟ (key-value ਜੋੜ), ਐਰੇ, ਨੇਸਟਡ ਤੱਤ, ਅਤੇ ਕਈ ਕਿਸਮਾਂ (number, string, boolean, null) ਸ਼ਾਮਲ ਹਨ। ਉਦਾਹਰਣ ਵਜੋਂ, ਇੱਕ API ਤੋਂ ਮਿਲਿਆ JSON ਇਸ ਤਰ੍ਹਾਂ ਹੋ ਸਕਦਾ ਹੈ:
{
"name": "ਅਮਰ",
"age": 30,
"address": {
"city": "ਚੰਡੀਗੜ੍ਹ",
"zip": "160001"
}
}
CSV (Comma-Separated Values) ਇੱਕ ਫਲੈਟ, ਸਾਰਣੀ-ਅਧਾਰਿਤ ਫ਼ਾਰਮੈਟ ਹੈ ਜਿਸ ਵਿੱਚ ਸਿਰਫ਼ ਟੈਕਸਟ ਵੈਲਿਊ ਹੁੰਦੇ ਹਨ, ਕੋਈ ਕਿਸਮਾਂ ਨਹੀਂ, ਕੋਈ ਨੇਸਟਿੰਗ ਨਹੀਂ। JSON ਤੋਂ CSV ਵਿੱਚ ਪਰਿਵਰਤਨ ਕਰਦੇ ਸਮੇਂ, ਸਾਰੀ ਦਰਜੇਬੰਦ ਬਣਤਰ ਅਤੇ ਕਿਸਮ ਜਾਣਕਾਰੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਜੋ ਬਚਦਾ ਹੈ ਉਹ ਸਿਰਫ਼ ਸਤਰ-ਅਧਾਰਿਤ ਮੁੱਲ ਹੁੰਦੇ ਹਨ।
ਨੇਸਟਡ JSON ਨੂੰ ਫਲੈਟ ਕਰਨ ਦਾ ਤਰੀਕਾ: Dot-Path Notation
ਜਦੋਂ JSON ਵਿੱਚ ਨੇਸਟਡ ਆਬਜੈਕਟ ਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ address.city), ਤਾਂ CSV/ਸਾਰਣੀ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਪ੍ਰਸਤੁਤ ਕਰਨ ਲਈ ਇੱਕ ਸਟੈਂਡਰਡ ਤਕਨੀਕ ਵਰਤੀ ਜਾਂਦੀ ਹੈ: ਡੌਟ-ਪਾਥ ਨੋਟੇਸ਼ਨ। ਇਸ ਵਿੱਚ ਹਰ ਨੇਸਟਡ ਕੁੰਜੀ ਨੂੰ ਇੱਕ ਡੌਟ (.) ਨਾਲ ਜੋੜ ਕੇ ਕਾਲਮ ਦਾ ਨਾਮ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਉਪਰੋਕਤ JSON ਲਈ, CSV ਕਾਲਮ ਹੋਣਗੇ: name, age, address.city, address.zip।
ਐਰੇ (Arrays) ਦਾ ਵਿਵਹਾਰ
- ਆਬਜੈਕਟਾਂ ਦਾ ਐਰੇ: ਜੇਕਰ JSON ਇੱਕ ਐਰੇ ਦੇ ਅੰਦਰ ਆਬਜੈਕਟਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ, ਤਾਂ ਹਰ ਆਬਜੈਕਟ ਇੱਕ ਵੱਖਰੀ ਕਤਾਰ ਬਣੇਗੀ। ਕੁੰਜੀਆਂ ਕਾਲਮ ਬਣਦੀਆਂ ਹਨ, ਨੇਸਟਡ ਕੁੰਜੀਆਂ ਨੂੰ ਡੌਟ-ਪਾਥ ਨਾਲ ਫਲੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
- ਐਰੇ ਦਾ ਐਰੇ: ਜੇਕਰ JSON ਸਿਰਫ਼ ਅੰਦਰੂਨੀ ਐਰੇ ਵਾਲਾ ਇੱਕ ਬਾਹਰੀ ਐਰੇ ਹੈ (ਜਿਵੇਂ ``), ਤਾਂ ਹਰ ਅੰਦਰੂਨੀ ਐਰੇ ਇੱਕ ਕਤਾਰ ਬਣ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਐਰੇ ਦੇ ਤੱਤ ਕਾਲਮ ਬਣਦੇ ਹਨ (ਕੋਈ ਆਬਜੈਕਟ ਕੁੰਜੀਆਂ ਨਹੀਂ)।
ਮਹੱਤਵਪੂਰਨ ਨੋਟ
ਟੂਲ ਸਿਰਫ਼ ਟੇਬਲ-ਸ਼ੇਪਡ JSON ਨੂੰ ਹੀ ਪਰਿਵਰਤਿਤ ਕਰ ਸਕਦਾ ਹੈ। "ਟੇਬਲ-ਸ਼ੇਪਡ" ਤੋਂ ਭਾਵ ਇੱਕ ਇੱਕੋ-ਜਿਹੀ ਬਣਤਰ ਵਾਲਾ (ਜਾਂ ਤਾਂ ਆਬਜੈਕਟਾਂ ਦਾ ਐਰੇ, ਜਾਂ ਐਰੇ ਦਾ ਐਰੇ) JSON। ਜੇਕਰ JSON ਅਵੈਧ ਹੈ ਜਾਂ ਟੇਬਲ-ਸ਼ੇਪਡ ਨਹੀਂ, ਤਾਂ ਗਲਤੀ ਸੰਦੇਸ਼ ਆਉਂਦਾ ਹੈ: “This JSON is invalid or not table‑shaped.”
ਡਿਲੀਮੀਟਰ ਦੀ ਚੋਣ ਅਤੇ CSV ਮਾਪਦੰਡ
CSV ਫ਼ਾਰਮੈਟ ਵਿੱਚ, ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਨੂੰ ਇੱਕ ਡਿਲੀਮੀਟਰ (separator) ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਟੂਲ ਤਿੰਨ ਡਿਲੀਮੀਟਰਾਂ ਦੀ ਚੋਣ ਦਿੰਦਾ ਹੈ:
| ਡਿਲੀਮੀਟਰ | ਚਿੰਨ੍ਹ | ਵਰਤੋਂ |
|---|---|---|
| ਕੌਮਾ | , |
ਮਿਆਰੀ CSV (RFC 4180) |
| ਸੈਮੀ-ਕੌਲਨ | ; |
ਯੂਰਪੀਅਨ ਲੋਕੇਲ (Excel ਵਿੱਚ ਆਮ) |
| ਟੈਬ | \t |
TSV (Tab-Separated Values) |
ਡਿਲੀਮੀਟਰ ਦੀ ਚੋਣ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਜੇਕਰ ਡੇਟਾ ਵਿੱਚ ਹੀ ਕੌਮਾ ਹੈ (ਜਿਵੇਂ "ਅਮਰ, 30"), ਤਾਂ CSV ਨੂੰ ਸਹੀ ਨਹੀਂ ਪੜ੍ਹਿਆ ਜਾਵੇਗਾ। ਇਸ ਲਈ ਟੂਲ ਆਪਣੇ-ਆਪ CSV quoting ਨਿਯਮ ਲਾਗੂ ਕਰਦਾ ਹੈ: ਕੌਮੇ, ਨਵੀਆਂ ਲਾਈਨਾਂ, ਅਤੇ ਅੰਦਰੂਨੀ quotes (") ਵਾਲੇ ਵੈਲਿਊਜ਼ ਨੂੰ double quotes "..." ਵਿੱਚ ਘੇਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।
Leading Zeros ਦਾ ਨੁਕਸਾਨ
CSV ਦੀ ਟੈਕਸਟ-ਪ੍ਰਕਿਰਤੀ ਕਾਰਨ, ਨੰਬਰਾਂ ਦੇ ਅਗਲੇ ਜ਼ੀਰੋ (leading zeros) ਆਮ ਤੌਰ 'ਤੇ ਖੁੰਝ ਜਾਂਦੇ ਹਨ। ਉਦਾਹਰਣ: JSON ਵਿੱਚ "zip": "00100" (ਸਤਰ) CSV ਵਿੱਚ 00100 ਵਜੋਂ ਰਹੇਗਾ, ਪਰ "zip": 00100 (ਨੰਬਰ) CSV ਵਿੱਚ 100 ਬਣ ਜਾਵੇਗਾ – ਕਿਉਂਕਿ JSON ਨੰਬਰ ਪਾਰਸ ਕਰਦੇ ਸਮੇਂ leading zeros ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ। ਪਰ ਇਹ ਵੀ ਯਾਦ ਰੱਖੋ: JSON ਵਿੱਚ 00100 ਨੂੰ ਨੰਬਰ ਵਜੋਂ ਲਿਖਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ (ਲੀਡਿੰਗ ਜ਼ੀਰੋ ਨਾਲ ਨੰਬਰ ਅਵੈਧ ਹੁੰਦੇ ਹਨ) – ਇਸ ਲਈ ਅਸਲ ਵਿੱਚ ਨੁਕਸਾਨ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ JSON ਮੂਲ ਰੂਪ ਵਿੱਚ ਨੰਬਰ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਸਤਰ ਨਹੀਂ।
ਡਾਟਾ ਕਿਸਮਾਂ ਦਾ ਨੁਕਸਾਨ: JSON ਤੋਂ CSV
CSV ਸਿਰਫ਼ ਟੈਕਸਟ (string) ਸਟੋਰ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ JSON ਕਿਸਮਾਂ ਅਤੇ CSV ਵਿੱਚ ਉਹਨਾਂ ਦੇ ਬਦਲਵੇਂ ਰੂਪ ਦੀ ਸੂਚੀ ਹੈ:
| JSON ਕਿਸਮ | CSV ਵਿੱਚ | ਉਦਾਹਰਣ |
|---|---|---|
| Number | String | 30 → "30" |
| Boolean | String | true → "true" |
| null | Empty cell | null → "" |
| String | String | "ਚੰਡੀਗੜ੍ਹ" → "ਚੰਡੀਗੜ੍ਹ" |
| Array | String (flat) | `` → "" (JSON array string) |
| Object | String (flat) | {"a":1} → "{\"a\":1}" (JSON object string) |
ਨੋਟ ਕਰੋ: JSON ਵਿੱਚ null ਅਤੇ "null" (ਸਤਰ) ਵਿੱਚ ਫ਼ਰਕ ਹੈ, ਪਰ CSV ਵਿੱਚ null ਇੱਕ ਖਾਲੀ ਸੈੱਲ ਵਜੋਂ ਦਿਖਾਈ ਦੇਵੇਗਾ – ਕਿਸਮਾਂ ਦੀ ਜਾਣਕਾਰੀ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ।
ਪ੍ਰਾਈਵੇਸੀ ਅਤੇ ਕਲਾਈਂਟ-ਸਾਈਡ ਪ੍ਰੋਸੈਸਿੰਗ
ਇਸ ਟੂਲ ਦੀ ਸਭ ਤੋਂ ਵੱਡੀ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਕੋਈ ਵੀ ਡਾਟਾ ਤੁਹਾਡੇ ਬਰਾਊਜ਼ਰ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਂਦਾ। ਸਾਰਾ ਪਰਿਵਰਤਨ ਬਰਾਊਜ਼ਰ 'ਚ ਹੀ ਹੁੰਦਾ ਹੈ। ਇਹ ਸੰਵੇਦਨਸ਼ੀਲ JSON ਡਾਟਾ (ਜਿਵੇਂ API keys, ਨਿੱਜੀ ਜਾਣਕਾਰੀ) ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਸੁਰੱਖਿਅਤ ਹੈ।
ਨਿਯਮ ਅਤੇ ਗਲਤੀਆਂ
ਫਾਈਲ ਸੀਮਾਵਾਂ
| ਮਾਪਦੰਡ | ਸੀਮਾ | ਗਲਤੀ ਸੰਦੇਸ਼ |
|---|---|---|
| ਫਾਈਲ ਆਕਾਰ | 8 MB | “This file is too large. Use a file under ‹max›.” |
| ਕਤਾਰਾਂ | 10,000 ਕਤਾਰਾਂ | “This table has more than ‹max› rows.” |
| ਕਾਲਮ | 200 ਕਾਲਮ | “This table has more than ‹max› columns.” |
ਸ਼ਰਤਾਂ ਅਤੇ ਗਲਤੀ ਸੁਨੇਹੇ
- “Choose a CSV, JSON or XLSX file.” – ਗਲਤ ਫ਼ਾਰਮੈਟ।
- “This file is too large. Use a file under ‹max›.” – ਫਾਈਲ ਆਕਾਰ ਸੀਮਾ ਪਾਰ।
- “This JSON is invalid or not table-shaped.” – JSON ਅਵੈਧ ਜਾਂ ਟੇਬਲ-ਸ਼ੇਪਡ ਨਹੀਂ।
- “This conversion is taking too long. Try a smaller file.” – ਸਮਾਂ ਸੀਮਾ ਪਾਰ।
- “This file has no table rows.” – ਫਾਈਲ ਵਿੱਚ ਕੋਈ ਕਤਾਰਾਂ ਨਹੀਂ।
- “Conversion cancelled.” – ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਰੱਦ।
- “Could not convert this file.” – ਪਰਿਵਰਤਨ ਅਸਫ਼ਲ।
JSON ਲਈ ਲਾਜ਼ਮੀ: “table-shaped”
ਜੇਕਰ JSON ਦੀ ਬਣਤਰ ਇਕਸਾਰ ਨਹੀਂ (ਜਿਵੇਂ ਕਿ ਕੁਝ ਆਬਜੈਕਟਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕੁੰਜੀਆਂ), ਤਾਂ ਗਲਤੀ ਆਵੇਗੀ। “This JSON is invalid or not table‑shaped.” – ਦਾ ਮਤਲਬ ਹੈ ਕਿ JSON ਵਿੱਚ ਜਾਂ ਤਾਂ ਗਲਤ ਸਿੰਟੈਕਸ ਹੈ, ਜਾਂ ਡੇਟਾ ਨੂੰ ਕਤਾਰਾਂ ਵਿੱਚ ਬਦਲਣਾ ਸੰਭਵ ਨਹੀਂ।
FAQ
1. ਕੀ JSON ਦੀਆਂ nested objects ਨੂੰ CSV ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ?
ਨਹੀਂ, CSV ਸਿਰਫ਼ ਫਲੈਟ ਸਾਰਣੀ ਹੈ। nested objects ਨੂੰ dot-path notation (ਜਿਵੇਂ address.city) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਾਲਮਾਂ ਵਿੱਚ ਤੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਮੂਲ ਬਣਤਰ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ।
2. ਕੀ ਮੈਂ CSV ਤੋਂ ਦੁਬਾਰਾ JSON 'ਚ ਬਦਲ ਸਕਦਾ ਹਾਂ?
ਹਾਂ, ਪਰ nested structure ਅਤੇ data types (number, boolean, null) ਦੀ ਜਾਣਕਾਰੀ ਖਤਮ ਹੋ ਚੁੱਕੀ ਹੁੰਦੀ ਹੈ। round-trip workaround: CSV ਕਾਲਮਾਂ ਤੋਂ dot-path ਨੂੰ JSON object tree 'ਚ ਮੁੜ-ਬਣਾਉਣਾ ਪੈਂਦਾ ਹੈ, ਪਰ type info ਗੁਆਚ ਜਾਂਦੀ ਹੈ।
3. JSON 'ਚ null value CSV 'ਚ ਕਿਵੇਂ ਦਿਖੇਗਾ?
CSV 'ਚ null ਇੱਕ ਖਾਲੀ ਸੈੱਲ ਵਜੋਂ ਦਿਖਾਈ ਦੇਵੇਗਾ।
4. ਕੀ leading zeros (ਜਿਵੇਂ 00123) CSV 'ਚ ਸੁਰੱਖਿਅਤ ਰਹਿਣਗੇ?
ਜੇਕਰ JSON 'ਚ "00123" (string) ਹੈ, ਤਾਂ CSV 'ਚ 00123 ਰਹੇਗਾ। ਪਰ ਜੇਕਰ 0123 ਨੂੰ number (123) ਵਜੋਂ ਸਟੋਰ ਕੀਤਾ ਗਿਆ, ਤਾਂ JSON ਪਾਰਸਰ ਇਸਨੂੰ 123 ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇ CSV 'ਚ 123 ਹੋਵੇਗਾ – leading zeros ਖਤਮ। JSON numbers 'ਚ leading zeros ਅਵੈਧ ਹੁੰਦੇ ਹਨ।
5. ਟੂਲ ਕਿਹੜੇ delimiter ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹੈ?
ਇਹ ਉਪਭੋਗਤਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜੇਕਰ CSV ਨੂੰ Excel 'ਚ ਖੋਲ੍ਹਣਾ ਹੈ ਅਤੇ locale point (,) comma delimiter ਲਈ ਸੁਰੱਖਿਅਤ ਹੈ, ਤਾਂ comma (,) ਦੀ ਵਰਤੋਂ ਕਰੋ। European locale 'ਚ semicolon (;) ਆਮ ਹੈ। Tab delimiter TSV 'ਚ ਮਦਦਗਾਰ ਹੈ ਜੇਕਰ data 'ਚ commas ਜਾਂ semicolons ਹੋਣ।
6. ਕੀ processing 100% client-side ਹੋਣ ਦਾ ਕੀ ਲਾਭ ਹੈ?
ਕੋਈ ਡਾਟਾ internet 'ਤੇ ਨਹੀਂ ਜਾਂਦਾ, ਇਸ ਲਈ confidential JSON (API keys, personal records) ਸੁਰੱਖਿਅਤ ਰਹਿੰਦੇ ਹਨ। ਕੋਈ server queue ਨਹੀਂ, processing instant ਹੈ (size limit 'ਤੇ ਨਿਰਭਰ)।