# JSON முதல் XML: உறுப்புப் பெயர்கள், அணிகள், மாற்றியால் வெளிப்படுத்த முடியாதவை

> இந்த மாற்றியின் துல்லிய விதிகள்: நிலையான <root>, அணிகள் <item> ஆக, null வெற்றுக் குறிச்சொல்லாக, பண்புக்கூறுகள் இல்லை, விசைப் பெயர் சுத்திகரிப்பும் அதன் மோதல்களும், கட்டுப்பாட்டு எழுத்துகளில் ஒரு அறியப்பட்ட இடைவெளி.

- Tool: [JSON முதல் XML மாற்றி](https://toolsg.com/ta/json-to-xml)
- 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.

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

| விவரம் | மதிப்பு | ஆதாரம் |
| --- | --- | --- |
| வேர் உறுப்பு | எப்போதும் <root> — பெயர் மாற்ற வழியில்லை; XML அறிவிப்பும் எழுதப்படாது. |  |
| அணி உறுப்புகள் | ஒவ்வொன்றும் <item> ஆகும் — அணியின் சொந்த விசை சுற்று உறுப்பாகும். |  |
| பண்புக்கூறுகள் | ஒருபோதும் உருவாக்கப்படாது — ஒவ்வொரு JSON உறுப்பும் குழந்தை உறுப்பாகும்; எனவே XML பண்புக்கூறுகளை உருவாக்க முடியாது. |  |
| எஸ்கேப் செய்யப்படும் எழுத்துகள் | உரையில் & < > " — அபாஸ்ட்ரஃபி அப்படியே விடப்படும்; உறுப்பு உரையில் அது எஸ்கேப் ஆக வேண்டியதில்லை. |  |

## பொருத்தம்

JSON-ஐ ஒட்டினால் வலப்பெட்டி உள்தள்ளிய XML-ஐக் காட்டும் (ஒவ்வொரு நிலைக்கும் இரு இடைவெளிகள்). எதுவும் பதிவேற்றப்படாது. கீழுள்ள விதிகள் மாற்றியின் குறியீட்டிலிருந்து எடுக்கப்பட்டு மாதிரி உள்ளீட்டில் இயக்கிச் சரிபார்க்கப்பட்டவை:

| JSON | XML |
| --- | --- |
| பொருள் `{"a":1}` | `<root><a>1</a></root>` (குழந்தைகள் தனி வரிகளில் உள்தள்ளப்படும்) |
| அணி `[1,2]` | `<root><item>1</item><item>2</item></root>` |
| விசை `tags` கீழ் உள்ளமைந்த அணி | `<tags><item>a</item><item>b</item></tags>` |
| `null` | தானே மூடும் `<none/>` |
| `{}` (வெற்றுப் பொருள்) | தானே மூடும் `<obj/>` |
| `[]` (வெற்று அணி) | உள்ளடக்கம் ஒரு வெற்று வரியாக உள்ள உறுப்பு |
| `""` (வெற்றுச் சரம்) | `<s></s>` |
| `true`, `1.50` | `<t>true</t>`, `<n>1.5</n>` (எண்கள் JavaScript முறையில் அச்சாகும்) |
| தனி மதிப்பு `5` | `<root>5</root>` |
| மேல்நிலை `null` | `<root/>` |

எடுத்துக்காட்டு: `[{"name":"Mei","city":"Singapore","age":30},{"name":"Ali","city":"Johor","age":25}]` என்பது

```xml
<root>
  <item>
    <name>Mei</name>
    <city>Singapore</city>
    <age>30</age>
  </item>
  <item>
    <name>Ali</name>
    <city>Johor</city>
    <age>25</age>
  </item>
</root>
```

`<?xml ... ?>` அறிவிப்பு இல்லை; பக்கம் குறியாக்கத்தையும் தேர்வு செய்யாது. பெறுபவருக்கு அறிவிப்பு தேவையெனில் உரையை நகலெடுத்து அல்லது பதிவிறக்கி (`converted.xml`) நீங்களே சேருங்கள்.

## உறுப்புப் பெயர்கள் சுத்திகரிக்கப்படுகின்றன

XML பெயர்கள் JSON விசைகளை விடக் கடுமையானவை: இலக்கத்தில் தொடங்கக்கூடாது, இடைவெளி இருக்கக்கூடாது. `A–Z a–z 0–9 _ . -` தவிர்ந்த ஒவ்வொரு எழுத்தையும் மாற்றி `_` ஆக்கி, முடிவு எழுத்து அல்லது அடிக்கோட்டில் தொடங்கவில்லையெனில் முன்னால் `_` சேர்க்கும்:

| JSON விசை | உறுப்பு |
| --- | --- |
| `first name` | `<first_name>` |
| `1st` | `<_1st>` |
| `@id`, `#text` | `<_id>`, `<_text>` |
| `a:b` | `<a_b>` |
| `x.y-z` | `<x.y-z>` (மாற்றமில்லை) |
| `名字` | `<__>` (ASCII அல்லாத எழுத்துகள் மாற்றப்படும்; XML பல எழுத்துகளை அனுமதித்தாலும்) |
| வெற்று விசை `""` | `<_>` |

இரு விளைவுகள் முக்கியம். வெவ்வேறு விசைகள் மோதலாம்: `a b`, `a:b`, `a_b` மூன்றும் `<a_b>` ஆகும்; XML மீண்ட உறுப்புகளைத் தடுக்காததால் தரவு இழக்கப்படாது, ஆனால் வேறுபாடு போய்விடும். லத்தீன் அல்லாத எழுத்துகளில் உள்ள விசைகள் அடிக்கோடுகளாக மாறும்; அந்த ஆவணங்களின் XML படிக்க முடியாததாகும். உங்கள் தரவில் அத்தகைய விசைகள் இருந்தால், மாற்றும் முன் பெயர் மாற்றுங்கள்.

## உரை எஸ்கேப் செய்யப்படும், ஆனால் சரிபார்க்கப்படாது

மதிப்புகளில் உள்ள `&`, `<`, `>`, `"` ஆகியவை `&amp;`, `&lt;`, `&gt;`, `&quot;` ஆகும்; எனவே `Mei & Co <x>` பாதுகாப்பானது. சரங்களுக்குள் உள்ள வரி முறிவுகளும் தாவல்களும் அப்படியே நகலாகும். ஓர் இடைவெளி: தாவல், வரி ஊட்டம், கேரியேஜ் ரிட்டர்ன் தவிர்ந்த கட்டுப்பாட்டு எழுத்துகள் மாற்றமின்றி நகலாகும்; ஆனால் XML 1.0 அவற்றைத் தடை செய்கிறது (சட்டபூர்வ எழுத்துகள் U+0020 முதல் தொடங்கும்; தாவல், வரி ஊட்டம், கேரியேஜ் ரிட்டர்ன் தவிர); எனவே `"\u0001"` போன்ற JSON சரம் XML பகுப்பாய்வி மறுக்கும் வெளியீட்டைத் தரும். அத்தகைய எழுத்துகளை முன்கூட்டியே நீக்குங்கள்.

## வெளிப்படுத்த முடியாதவை

- **பண்புக்கூறுகள்**: எல்லாம் உறுப்புகளாகும். `<person id="1">` வேண்டுமெனில் XML-ஐ வேறு வழியில் உருவாக்குங்கள்.
- **சுற்றிவருதல்**: JSON → XML → JSON ஒவ்வொரு அணியையும் மீண்ட `item` குழந்தைகளாகவும், ஒவ்வொரு எளிய மதிப்பையும் சரமாகவும் மாற்றும். [XML முதல் JSON](https://toolsg.com/ta/xml-to-json) பண்புக்கூறுகளை `@name` எனப் படிக்கும்; ஆனால் இந்த மாற்றி `@name`-ஐ `<_name>` என எழுதும்.
- **வகைகள்**: `5`, `"5"`, `true` அனைத்தும் எளிய உரையாகத் தோன்றும். எது எது என அறிய பெறுபவருக்கு ஸ்கீமா தேவை.
- **நிலையான வேர்**: இலக்கு குறிப்பிட்ட ஆவண உறுப்பை எதிர்பார்த்தால், வெளியீட்டில் `<root>`-இன் பெயரை மாற்றுங்கள்.
- **கலப்பு உள்ளடக்கத்துக்கு** இங்கே JSON இணை இல்லை.

> **குறிப்பு:** தரவு ஊட்டங்களுக்கு, முதலில் மதிப்புகளை ஒரு-விசைப் பொருளில் சுற்றுங்கள், எ.கா. `{"orders":[…]}`; முடிவு `<root><orders><item>…` ஆகும். இது வெறும் `<root><item>`-ஐ விட பெரும்பாலான XML ஸ்கீமாக்கள் எதிர்பார்ப்பதற்கு நெருக்கம்.

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

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

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

திரும்ப மாற்ற [XML முதல் JSON](https://toolsg.com/ta/xml-to-json), மூலத்தைச் சோதிக்க [JSON சரிபார்ப்பி](https://toolsg.com/ta/json-validator), பாதைகளைக் காண [JSON முதல் உரை](https://toolsg.com/ta/json-to-text), அட்டவணை உருவாக்க [JSON முதல் CSV](https://toolsg.com/ta/json-to-csv).

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

**என் தரவு எங்காவது பதிவேற்றப்படுகிறதா?**

இல்லை. மாற்றம் முழுவதும் உங்கள் உலாவியில் JavaScript மூலம் நடக்கிறது. நீங்கள் ஒட்டுவது உங்கள் சாதனத்தை விட்டு வெளியேறாது, பதிவு செய்யப்படாது, சேவையகத்தில் சேமிக்கப்படாது.

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

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

**உள்ளமை தரவுக்கு என்ன நடக்கும்?**

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

**புலங்களுக்குள் உள்ள மேற்கோள்களையும் காற்புள்ளிகளையும் கையாளுமா?**

ஆம். பாகுபடுத்தல் RFC 4180-ஐப் பின்பற்றுகிறது, எனவே காற்புள்ளி கொண்ட மேற்கோள் புலங்கள், தப்பிக்கப்பட்ட இரட்டை மேற்கோள்கள், புலத்திற்குள் வரி முறிவுகள் அனைத்தும் சரியாகப் படிக்கப்பட்டு எழுதப்படும்.


## ஆதாரங்கள்

- [W3C — Extensible Markup Language (XML) 1.0, Fifth Edition](https://www.w3.org/TR/xml/) — Names (section 2.3), legal characters (section 2.2), escaping and well-formedness.
- [IETF — RFC 8259, The JSON Data Interchange Format](https://www.rfc-editor.org/rfc/rfc8259.html) — The JSON input.
