# JSON சுருக்கம்: எது நீக்கப்படுகிறது, எது மாற்றி எழுதப்படுகிறது, எவ்வளவு சேமிக்கலாம்

> சுருக்கி JSON-ஐ வெற்றிடமின்றி எவ்வாறு மறு-வரிசைப்படுத்துகிறது, எந்த எழுத்துகளும் எண்களும் மாற்றி எழுதப்படுகின்றன, நடைமுறையில் எவ்வளவு அளவு குறையும், பைட் அளவில் பாதுகாப்பற்ற சூழல்கள்.

- Tool: [JSON சுருக்கி](https://toolsg.com/ta/json-minify)
- Language: ta (available: en, zh, ms, ta)
- Last verified against official sources: 2026-10-19
- Source site: ToolSG — a planning guide, not official or financial advice. Cite the agencies listed under Sources.

## முக்கிய எண்கள் ஒரே பார்வையில்

| விவரம் | மதிப்பு | ஆதாரம் |
| --- | --- | --- |
| முறை | JSON.parse, பின் உள்தள்ளலின்றி JSON.stringify — மதிப்பை மாற்றி எழுதுதல்; இடைவெளிகளை நீக்கும் regex அல்ல. |  |
| எப்போது இயங்கும் | ஒவ்வொரு விசை அழுத்தத்திலும் ஒட்டலிலும் — Minify பொத்தான் இல்லை; நீங்கள் தட்டச்சு செய்யும்போதே வெளியீடு புதுப்பிக்கப்படும். |  |
| வழக்கமான சேமிப்பு | 2 இடைவெளி JSON-இல் சுமார் 42%, 4 இடைவெளியில் சுமார் 55% — கீழ்க்காணும் 100 பதிவு எடுத்துக்காட்டில் அளந்தது; ஆழமான உள்ளமைவில் அதிகம், அடர்ந்த எண் அணிகளில் குறைவு. |  |
| சரங்களுக்குள் இருக்கும் வெற்றிடம் | அப்படியே வைக்கப்படும் — டோக்கன்களுக்கு இடையிலான வெற்றிடம் மட்டுமே நீக்கப்படும். |  |

## கருவி என்ன செய்கிறது

JSON-ஐ ஒட்டியதும் வலப்பெட்டி உடனே ஒரு வரிப் பதிப்பைக் காட்டும். உள்ளே, பக்கம் உள்ளீட்டில் `JSON.parse`-ஐயும், முடிவில் உள்தள்ளல் வாதமின்றி `JSON.stringify`-ஐயும் இயக்கும். உரை செல்லுபடியாகும் JSON அல்ல என்றால் வெளியீடு வெறுமையாக இருக்கும், பிழை சிவப்பில் வரும்; எதுவும் ஊகிக்கப்படுவதோ சரிசெய்யப்படுவதோ இல்லை. உள்ளீடு வெறுமையானால் எல்லாம் அழியும். நகலெடு பொத்தான் வெளியீட்டை நகலெடுக்கும் (பெயர் சிறிது நேரம் "நகலெடுக்கப்பட்டது" என மாறும்); இந்தப் பக்கத்தில் பதிவிறக்கப் பொத்தான் இல்லை.

RFC 8259, ஆறு கட்டமைப்பு எழுத்துகள், மதிப்புகளைச் சுற்றி முக்கியமற்ற வெற்றிடத்தை (இடைவெளி, தாவல், வரி ஊட்டம், கேரியேஜ் ரிட்டர்ன்) அனுமதிக்கிறது. அதை நீக்குவது தரவு மாதிரியை மாற்றாது; எனவே சுருக்கிய JSON-உம் அழகாக்கிய JSON-உம் பகுப்பாய்விகளுக்குச் சமம்.

## கணக்கிட்ட எடுத்துக்காட்டு

உள்ளீடு (186 UTF-8 பைட்டுகள்):

```json
{
    "name": "Mei Tan",
    "city": "Singapore",
    "scores": [
        90,
        85.50,
        1e2
    ],
    "note": "a  b\/c é 中",
    "active": true,
    "spouse": null
}
```

வெளியீடு (111 பைட்டுகள், 75 சேமிப்பு, 40.3%):

```json
{"name":"Mei Tan","city":"Singapore","scores":[90,85.5,100],"note":"a  b/c é 中","active":true,"spouse":null}
```

மற்ற மாற்றங்களைக் கவனியுங்கள்: `85.50` என்பது `85.5` ஆனது, `1e2` என்பது `100` ஆனது, `\/` என்பது `/` ஆனது, `é` என்பது `é` ஆனது. `"a  b"`-இலுள்ள இரு இடைவெளிகள் அப்படியே இருந்தன.

## எவ்வளவு சேமிக்கலாம்

சேமிப்பு உள்தள்ளல், உள்ளமைவைப் பொறுத்தது. 100 சிறு பதிவுகளின் (`id`, `name`, `city`, இரு உறுப்பு `tags` அணி, `active`) அணிக்கு:

| மூல அமைப்பு | பைட்டுகள் | சுருக்கிய பைட்டுகள் | சேமிப்பு |
| --- | --- | --- | --- |
| 2 இடைவெளி உள்தள்ளல் | 13,236 | 7,735 | 41.6% |
| 4 இடைவெளி உள்தள்ளல் | 17,236 | 7,735 | 55.1% |

பெரும்பாலான வலை சேவையகங்கள் பயன்படுத்தும் gzip-க்குப் பிறகு இடைவெளி வெகுவாகக் குறையும்: 2 இடைவெளிப் பதிப்பு 664 பைட்டுகள், சுருக்கியது 597; ஏனெனில் திரும்பத் திரும்ப வரும் வெற்றிடம் எளிதில் அமுக்கப்படும். சேமிப்பு, பதிவுகளுக்குச் சுருக்குங்கள்; பதில் ஏற்கெனவே அமுக்கப்பட்டிருந்தால் பரிமாற்றத்தில் பெரிய சேமிப்பை எதிர்பார்க்காதீர்கள்.

## பைட் அளவில் ஒன்றாக இல்லாத சூழல்கள்

- **எண்கள்** JavaScript double வழியாக மீண்டும் அச்சிடப்படும். `12345678901234567890` என்பது `12345678901234567000` ஆகும், `1e400` என்பது `null` ஆகும்.
- **நகல் விசைகள்** கடைசியில் ஒன்றாகக் குறுகும்; `"2"` போன்ற முழு எண் வடிவ விசைகள் பிற விசைகளுக்கு முன்னே நகரும்.
- **எஸ்கேப்கள் டிகோட் செய்யப்படும்**: `</script>` என்பது நேரடி உரை `</script>` ஆக வரும். சுருக்கிய JSON-ஐ HTML `<script>` தொகுதிக்குள் பதித்தால், அந்தத் தொடர் தொகுதியை முன்கூட்டியே முடிக்கக்கூடும்; எனவே உங்கள் build படியில் `<`-ஐ மீண்டும் எஸ்கேப் செய்யுங்கள்.
- **வரிப் பிரிப்பிகள்**: U+2028, U+2029 மூல எழுத்துகளாக எழுதப்படும்; ES2019 முதல் சரங்களுக்குள் அவை அனுமதிக்கப்படுகின்றன.
- **JSON அல்லாதது** சுருக்கப்படாது: கருத்துரைகள், இறுதிக் காற்புள்ளிகள், ஒற்றை மேற்கோள்கள் பகுப்பாய்வைத் தோல்வியடையச் செய்யும். இது JSON சுருக்கி, JavaScript சுருக்கி அல்ல.

> **குறிப்பு:** கீழ்நிலை அமைப்பு ஆவணத்தின் சரியான பைட்டுகளில் கையொப்பமிட்டால் அல்லது ஹாஷ் செய்தால், ஒரு முறை மட்டும் சுருக்கி, முடிவைச் சேமித்து, சேமித்த நகலில் கையொப்பமிடுங்கள். பின்னர் வேறு கருவியில் சுருக்கினால் விசை வரிசையோ எண் வடிவமோ வேறுபடலாம்.

## பொதுவான தவறுகள்

- சரங்களுக்குள் உள்ள உரையும் சுருங்கும் என எதிர்பார்ப்பது: `"a  b"` இரு இடைவெளிகளையும் வைத்திருக்கும்; சரத்துக்குள் உள்ள `\n` எஸ்கேப்பாகவே இருக்கும்.
- 19 இலக்க ID உள்ள ஆவணத்தைச் சுருக்கி, கடைசி இலக்கங்கள் மாறியதைக் கண்டறிவது.
- சுருக்கிய கோப்பு குறியாக்கப்பட்டது அல்லது மறைக்கப்பட்டது என நினைப்பது; அதே தரவுதான், உடனே மீண்டும் வடிவமைக்கலாம்.
- பதிவிறக்கப் பொத்தானைத் தேடுவது; முடிவை நகலெடுங்கள், அல்லது பதிவிறக்கக்கூடிய [JSON வடிவமைப்பி](https://toolsg.com/ta/json-formatter) பக்கத்தைப் பயன்படுத்துங்கள்.

## தொடர்புடைய கருவிகள்

மீண்டும் அழகாக்க [JSON வடிவமைப்பி](https://toolsg.com/ta/json-formatter), தொடரியல் சோதிக்க [JSON சரிபார்ப்பி](https://toolsg.com/ta/json-validator), கட்டமைப்பை உலாவ [JSON பார்வையாளர்](https://toolsg.com/ta/json-viewer), பதிவுகளை மாற்ற [JSON முதல் CSV](https://toolsg.com/ta/json-to-csv). சாதாரண உரைக்கு [உரை சுருக்கி](https://toolsg.com/ta/text-minifier) பகுக்காமலே வெற்றிடத்தை நீக்கும்.

## அடிக்கடி கேட்கப்படும் கேள்விகள்

**சுருக்கினால் JSON எவ்வளவு சிறியதாகும்?**

அது டோக்கன்களுக்கு இடையிலான இடைவெளியை மட்டுமே நீக்குகிறது; எனவே சேமிப்பு கோப்பு எவ்வளவு உள்தள்ளப்பட்டது என்பதைப் பொறுத்தது. தரவு மாறாது.

**என் JSON சேவையகத்திற்கு அனுப்பப்படுகிறதா?**

இல்லை. அனைத்தும் உங்கள் உலாவியிலேயே நடக்கிறது. நீங்கள் ஒட்டுவது பதிவேற்றப்படவோ பதிவு செய்யப்படவோ சேமிக்கப்படவோ இல்லை — ஆவணத்தில் keys, tokens அல்லது தனிப்பட்ட தரவு இருக்கும்போது இது முக்கியம்.

**என் JSON ஏன் செல்லாதது எனக் கூறப்படுகிறது?**

மிகப் பொதுவான காரணங்கள்: இறுதியில் உள்ள காற்புள்ளி, keys மற்றும் சரங்களுக்கு இரட்டை மேற்கோளுக்குப் பதிலாக ஒற்றை மேற்கோள், சரத்திற்குள் தப்பிக்கப்படாத வரி முறிவுகள். பிழைச் செய்தி முதல் சிக்கலின் வரியையும் நெடுவரிசையையும் தரும்.

**இது என் தரவை மாற்றுமா?**

இல்லை. ஆவணம் பாகுபடுத்தப்பட்டு மீண்டும் வரிசைப்படுத்தப்படுகிறது, எனவே இடைவெளி மட்டுமே மாறும். Key வரிசை பாதுகாக்கப்படுகிறது, மதிப்புகள் தொடப்படுவதில்லை.

**பெரிய ஆவணங்களைக் கையாள முடியுமா?**

ஆம், உங்கள் உலாவியின் நினைவகத்திற்குள். சில மெகாபைட் ஆவணங்கள் சிக்கலின்றி இயங்கும்; மிகப் பெரிய கோப்புகள் பாகுபடுத்தும்போது பக்கத்தை சிறிது நிறுத்தலாம்.


## ஆதாரங்கள்

- [IETF — RFC 8259, The JSON Data Interchange Format](https://www.rfc-editor.org/rfc/rfc8259.html) — Insignificant whitespace, string escapes and number interoperability.
- [MDN — JSON.stringify()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
