# JSON வடிவமைப்பு: Format, Minify, Validate உண்மையில் என்ன செய்கின்றன

> வடிவமைப்புக் கருவி உலாவியின் JSON.parse மூலம் எவ்வாறு பகுப்பாய்கிறது, சுற்றிவந்த பின் எவை மாறும் (விசை வரிசை, பெரிய எண்கள், மீண்ட விசைகள்), பிழைச் செய்திகளை எப்படிப் படிப்பது.

- Tool: [JSON வடிவமைப்பான் & மினிஃபையர்](https://toolsg.com/ta/json-formatter)
- 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, கடுமையான RFC 8259 தொடரியல் — கருத்துரைகள், இறுதிக் காற்புள்ளி, ஒற்றை மேற்கோள், NaN ஆகியவை ஏற்கப்படாது. | [IETF — RFC 8259](https://www.rfc-editor.org/rfc/rfc8259.html) |
| உள்தள்ளல் தேர்வுகள் | 2 இடைவெளிகள், 4 இடைவெளிகள் அல்லது ஒரு தாவல் — Minify எந்த வெற்றிடமும் பயன்படுத்தாது. |  |
| எண்கள் | IEEE 754 இரட்டைத் துல்லியமாகப் பகுக்கப்படும் — 9007199254740991-ஐ மீறிய முழு எண்களும், சுமார் 17 குறிப்பிடத்தக்க இலக்கங்களுக்கு மேல் தேவைப்படும் தசமங்களும் மாறக்கூடும். |  |
| பதிவிறக்கம் | formatted.json — வடிவமைத்ததோ சுருக்கியதோ, வெளியீட்டுப் பெட்டியில் உள்ளதே கோப்பில் இருக்கும். |  |

## மூன்று பொத்தான்கள் எப்படி இயங்குகின்றன

பக்கம் உங்கள் உரையை `JSON.parse` மூலம் பகுத்து, வெற்றி பெற்றால் `JSON.stringify` மூலம் மீண்டும் எழுதுகிறது. எதுவும் எங்கும் அனுப்பப்படாது; அனைத்தும் உலாவியிலேயே நடக்கும்.

- **Format** தேர்ந்த உள்தள்ளலுடன் (2 இடைவெளிகள், 4 இடைவெளிகள் அல்லது தாவல்) எழுதும்.
- **Minify** டோக்கன்களுக்கு இடையே வெற்றிடமின்றி எழுதும்.
- **Validate** பகுத்து "செல்லுபடியாகும் JSON" அல்லது பிழையை மட்டும் காட்டும்; வெளியீட்டுப் பெட்டியை மாற்றாது.

தொடக்க, இறுதி வெற்றிடங்கள் முதலில் நீக்கப்படும். உள்ளீடு வெறுமையாக இருந்தால் "JSON தரவை உள்ளிடுங்கள்" என்று காட்டும். நிலைச் செய்தி மூன்று விநாடிகளில் மறையும்; உள்ளீட்டைத் திருத்தினால் வெளியீடு அழிக்கப்படும், பழைய முடிவு புதிய உரையுடன் நிற்காது.

வெளியீடு உரைத் திருத்தம் அல்ல, மறு-வரிசைப்படுத்தல் என்பதால், கிடைப்பது "இடைவெளி மட்டும் மாறிய உங்கள் உரை" அல்ல, "அதே தரவின் நியமன வடிவம்". கீழ்க்காணும் சூழல்களில் இது முக்கியம்.

## சுற்றிவந்தபின் மாறக்கூடியவை

| நீங்கள் ஒட்டுவது | வெளியீடு | காரணம் |
| --- | --- | --- |
| `{"b":1,"2":"x","1":"y"}` | விசைகள் `"1"`, `"2"`, பின் `"b"` | JavaScript முழு எண் வடிவ விசைகளை முதலில், ஏறுவரிசையில் பட்டியலிடும் |
| `{"a":1,"a":2}` | `{"a":2}` | கடைசி நகல் வெல்லும்; நகல்கள் இருந்தால் நடத்தை கணிக்க முடியாது என RFC 8259 கூறுகிறது |
| `12345678901234567890` | `12345678901234567000` | இரட்டைத் துல்லியம் சுமார் 15–17 குறிப்பிடத்தக்க இலக்கங்களையே வைத்திருக்கும் |
| `9007199254740993` | `9007199254740992` | 2^53 − 1-ஐ மீறினால் ஒவ்வொரு முழு எண்ணையும் குறிக்க முடியாது |
| `1.50`, `1.0`, `5E+2` | `1.5`, `1`, `500` | எண்கள் மீண்டும் அச்சிடப்படும்; உரையாகப் பாதுகாக்கப்படாது |
| `-0` | `0` | `JSON.stringify` எதிர்மறைப் பூஜ்ஜியத்தை `0` என எழுதும் |
| `1e400` | `null` | Infinity ஆகி வழியும்; `JSON.stringify` அதை `null` என எழுதும் |
| `"é"` | `"é"` | எஸ்கேப்கள் டிகோட் செய்யப்பட்டு, சட்டப்படி முடிந்தால் எழுத்தாகவே எழுதப்படும் |

இவை பக்கம் பயன்படுத்தும் அதே `JSON.parse`/`JSON.stringify` அழைப்புகளை இயக்கிப் பெற்றவை. பாதுகாப்பான விதி: சரங்கள், பூலியன்கள், null, அணிகள், சாதாரண எண்கள் ஆகியவற்றுக்கு வடிவமைப்பு இழப்பற்றது; மிகப் பெரிய அடையாள எண்கள், நகல் விசைகள், வரிசை முக்கியமான எண் வடிவ விசைகள் ஆகியவற்றுக்கு அது இழப்பற்றதல்ல. 19 இலக்க ID அப்படியே இருக்க வேண்டுமெனில் மூலத்தில் அதைச் சரமாக வைத்திருங்கள்.

## Format, minify, அளவு

`{"name":"Mei","tags":["a","b"],"n":{"x":1,"y":[]},"e":{}}` என்ற பொருள் சுருக்கியபின் 57 எழுத்துகள்; 2 இடைவெளி வடிவம் 102, 4 இடைவெளி 130, தாவல் 88 எழுத்துகள். வெற்று அணிகளும் பொருள்களும் `[]`, `{}` என ஒரே வரியில் இருக்கும். RFC 8259-இன்படி மேல்நிலை மதிப்பு எந்த JSON மதிப்பாகவும் இருக்கலாம்: `5`, `"text"`, `[]` ஆகியவை செல்லும்; பழைய பகுப்பாய்விகள் பொருள் அல்லது அணியை மட்டுமே ஏற்றன.

## பிழைச் செய்திகளைப் படித்தல்

இயந்திரச் செய்தியில் `position N` இருந்தால், கருவி அதை "வரி L, நெடுவரிசை C" ஆக மாற்றி, இயந்திரத்தின் சொந்த உரையையும் சேர்க்கும். செய்திகள் உங்கள் உலாவியிலிருந்து வருவதால் Chrome, Firefox, Safari இடையே சொற்கள் வேறுபடும்; சிலவற்றில் இடமே இருக்காது (எ.கா. `[NaN]` எதிர்பாராத `N` என்று மட்டும் சொல்லும்). பொதுவான காரணங்கள்:

| உள்ளீடு | சிக்கல் |
| --- | --- |
| `{"a":1,}` | இறுதிக் காற்புள்ளி: இரட்டை மேற்கோளிட்ட பண்புப் பெயர் எதிர்பார்க்கப்படுகிறது |
| `{'a':1}` | ஒற்றை மேற்கோள் JSON அல்ல |
| `[1,2` | மூடும் அடைப்புக்குறி இல்லை |
| `{"a":01}` | தொடக்கப் பூஜ்ஜியம் அனுமதி இல்லை |
| `{"a":"x⏎y"}` | சரத்துக்குள் மூல வரி முறிவு; `\n` என எழுதுங்கள் |
| `// note` அல்லது `/* */` | கருத்துரைகள் JSON-இல் இல்லை |
| `[NaN]`, `Infinity`, `undefined` | JSON மதிப்புகள் அல்ல |

> **குறிப்பு:** முதலில் காட்டப்படும் இடத்தைத் திருத்திவிட்டு மீண்டும் இயக்குங்கள். ஒரு மேற்கோள் விடுபட்டால் பல தொடர் பிழைகள் வரும், ஆனால் முதலாவதே உண்மையானது.

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

- JavaScript பொருள் literal-களை (மேற்கோளற்ற விசைகள், ஒற்றை மேற்கோள்) ஒட்டிவிட்டுச் செல்லும் என எதிர்பார்ப்பது.
- வடிவமைப்பு அசல் விசை வரிசையைப் பாதுகாக்கும் என நினைப்பது: எண் வடிவ விசைகள் முன்னே நகரும்.
- மிகப் பெரிய எண் ID-கள் கொண்ட ஆவணத்தைச் சுருக்கிவிட்டு, மூலத்துடன் இலக்கம் இலக்கமாக ஒப்பிடுவது.
- பதிவிறக்கத்தை அசல் கோப்பு என நினைப்பது; அது மறு-வரிசைப்படுத்திய வெளியீடு, பெயர் எப்போதும் `formatted.json`.

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

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

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

**4 இடைவெளி அல்லது டேப்புடன் JSON-ஐ எப்படி வடிவமைப்பது?**

எடிட்டருக்கு மேலுள்ள உள்தள்ளல் மெனுவில் 2 இடைவெளி, 4 இடைவெளி அல்லது டேப்பைத் தேர்ந்தெடுங்கள். வெளியீடு உடனே புதுப்பிக்கும்; பதிவிறக்கு அதை formatted.json ஆகச் சேமிக்கும்.

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

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

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

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

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

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

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

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


## ஆதாரங்கள்

- [IETF — RFC 8259, The JSON Data Interchange Format](https://www.rfc-editor.org/rfc/rfc8259.html) — Grammar, number interoperability, duplicate names and member order.
- [MDN — JSON.stringify()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) — Indent argument, Infinity and NaN written as null.
- [ECMAScript language specification](https://tc39.es/ecma262/) — Own-property ordering (integer-like keys first) used when objects are re-serialised.