# XML முதல் JSON பொருத்தம்: பண்புக்கூறுகள், மீண்ட உறுப்புகள், கைவிடப்படுபவை

> இந்த மாற்றி பயன்படுத்தும் துல்லியமான பொருத்தம்: பண்புக்கூறுகளுக்கு @, பண்புக்கூறுகளுடன் உள்ள உரைக்கு #text, மீண்ட பெயர்களுக்கு மட்டுமே அணி, ஒவ்வொரு மதிப்பும் சரம்; கலப்பு உள்ளடக்க உரை, கருத்துரைகள், அறிவிப்புகள் கைவிடப்படும்.

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

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

| விவரம் | மதிப்பு | ஆதாரம் |
| --- | --- | --- |
| பண்புக்கூறுகள் | @ முன்னொட்டுடன் விசைகள் (எ.கா. "@id") — பெயர்வெளி அறிவிப்புகளும் பண்புக்கூறுகளே; எனவே xmlns:ns என்பது "@xmlns:ns" எனத் தோன்றும். |  |
| பண்புக்கூறுடன் உள்ள உரை | "#text" விசையின் கீழ் சேமிக்கப்படும் — பண்புக்கூறு இல்லாத இலை உறுப்பு சாதாரண சரமாகும். |  |
| மீண்ட உறுப்புகள் | பெயர் ஒன்றுக்கு மேல் வந்தால் மட்டுமே அணியாகும் — ஒரு <item> பொருள் அல்லது சரத்தைத் தரும்; இரண்டு அணியைத் தரும். |  |
| மதிப்பு வகைகள் | எப்போதும் சரங்கள் — 12.50 என்பது "12.50" ஆகவே இருக்கும்; true என்பது "true". |  |

## மாற்றம் எப்படி நடக்கிறது

பக்கம் உங்கள் உரையை (தொடக்க, இறுதி வெற்றிடம் நீக்கி) `application/xml` ஆக உலாவியின் `DOMParser`-க்கு வழங்கும். உலாவி பகுப்புப் பிழை தெரிவித்தால், "இது சரியாக அமைக்கப்பட்ட XML அல்ல." என்ற நிலையான செய்தி மட்டுமே தெரியும்; வரி, நெடுவரிசை, காரணம் போன்ற விவரங்கள் காட்டப்படாது. இல்லையெனில் வேர் உறுப்பு ஒரே மேல்நிலை விசையாகும்; ஒவ்வொரு உறுப்பும் இந்த விதிகளின்படி JSON மதிப்பாகும் (உண்மையான பக்கத்தில் சரிபார்த்தவை):

| XML | JSON |
| --- | --- |
| `<a><b>Mei</b></a>` | `{"a":{"b":"Mei"}}` |
| `<a/>` அல்லது `<a></a>` | `{"a":""}` |
| `<price currency="SGD">12.50</price>` | `{"price":{"#text":"12.50","@currency":"SGD"}}` |
| `<a x="1"/>` | `{"a":{"#text":"","@x":"1"}}` |
| `<a><b>1</b><b>2</b></a>` | `{"a":{"b":["1","2"]}}` |
| `<a><b>1</b></a>` | `{"a":{"b":"1"}}` |
| `<a><b>1</b><c>x</c><b>2</b></a>` | `{"a":{"b":["1","2"],"c":"x"}}` |
| `<ns:a xmlns:ns="urn:x" ns:id="5"/>` | விசை `"ns:a"`, அதனுடன் `"@xmlns:ns"`, `"@ns:id"` |

வெளியீடு இரு இடைவெளி உள்தள்ளலுடன் வரும். அனைத்து மதிப்புகளும் சரங்கள்: மாற்றி எண்களையோ பூலியன்களையோ ஊகிக்காது; எனவே `12.50` பின்னால் உள்ள பூஜ்ஜியத்தை வைத்திருக்கும்.

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

```xml
<people><person id="1" active="true"><name>Mei</name></person><person id="2"><name>Ali</name></person></people>
```

```json
{
  "people": {
    "person": [
      { "@id": "1", "@active": "true", "name": "Mei" },
      { "@id": "2", "name": "Ali" }
    ]
  }
}
```

(பக்கம் ஒவ்வொரு பொருளையும் பல வரிகளில் அச்சிடும்.) ஒரே ஒரு `<person>` இருந்தால் அதே பாதை ஒரு உறுப்புள்ள அணியாக அல்லாமல் பொருளாக இருக்கும்.

## இழக்கப்படுபவை

- **கலப்பு உள்ளடக்கம்**: `<a>text<b>bold</b>more</a>` என்பதில் `{"a":{"b":"bold"}}` மட்டுமே எஞ்சும்; உறுப்புக்குக் குழந்தை உறுப்புகள் இருந்தால் `text`, `more` உரை முனைகள் கைவிடப்படும்.
- **குழந்தை உறுப்புகளும் பண்புக்கூறுகளும் உள்ள உறுப்பின் உரை** அதுபோலவே கைவிடப்படும்; பண்புக்கூறுகளும் குழந்தைகளும் மட்டுமே இருக்கும்.
- **கருத்துரைகள், செயலாக்க அறிவுறுத்தல்கள்** புறக்கணிக்கப்படும்; XML அறிவிப்பு முடிவில் இடம்பெறாது.
- **வெவ்வேறு பெயர்களுக்கிடையிலான வரிசை**: உடன்பிறப்புகள் பெயரால் குழுவாக்கப்படுவதால் `b, c, b` என்பது `b: [..], c` ஆகும். இடையிடையே வந்த வரிசையை மீட்க முடியாது.
- **CDATA** சாதாரண உரையுடன் இணையும்: `<![CDATA[1 < 2 & 3]]>` என்பது சரம் `1 < 2 & 3` ஆகும். என்டிட்டிகள் டிகோட் செய்யப்படும் (`&amp;&lt;&#65;` என்பது `&<A`).
- **வெற்றிடம்**: குழந்தை உறுப்புகளுக்கு இடையிலான உள்தள்ளல் புறக்கணிக்கப்படும்; ஆனால் உரை மட்டுமுள்ள உறுப்பு தன் இடைவெளிகளை வைத்திருக்கும்; எனவே `<a>  </a>` என்பது `"  "`.

## பிழைகளும் கடுமையும்

XML, HTML-ஐ விடக் கடுமையானது. உலாவி இவற்றை மறுக்கும்: ஒன்றுக்கு மேற்பட்ட வேர் (`<a/><b/>`), பொருந்தாத குறிச்சொற்கள் (`<a><b>1</a>`), மேற்கோளற்ற பண்புக்கூறு மதிப்புகள் (`<a b=1/>`), ஒரே குறிச்சொல்லில் மீண்ட பண்புக்கூறுகள், இலக்கத்தில் தொடங்கும் பெயர்கள் (`<1/>`), XML விவரக்குறிப்பு வரையறுக்காத என்டிட்டிகள் (`&nbsp;` போன்றவை; `amp`, `lt`, `gt`, `apos`, `quot` மட்டுமே முன்வரையறை). XML அல்லாத எளிய உரையும் மறுக்கப்படும். உள்ளீடு வெறுமையானால் வெளியீடும் வெறுமை, பிழை இல்லை.

உள்ளக DOCTYPE என்டிட்டிகளை உலாவியின் பகுப்பாய்வி கையாளும் (சோதனையில் `<!DOCTYPE a [<!ENTITY e "hi">]><a>&e;</a>` என்பது `"hi"` தந்தது); எனவே DOCTYPE அதிகமுள்ள ஆவணங்களின் முடிவு உலாவியைச் சார்ந்தது. DTD உள்ள நம்பகமற்ற XML-ஐ ஒட்டி ஒரே மாதிரி நடத்தையை எதிர்பார்க்காதீர்கள்.

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

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

- `"@id"`, `"#text"` ஆகியவற்றை உங்கள் தரவின் பகுதி என நினைப்பது. அவை இந்தக் கருவியின் மரபுகள்; மற்ற மாற்றிகள் `_attributes`, `$`, `attr_` பயன்படுத்தலாம்.
- எண்கள் அல்லது பூலியன்களை எதிர்பார்ப்பது: ஒவ்வொரு மதிப்பும் உரை.
- பல மேல்நிலை உறுப்புகள் கொண்ட XML துண்டை மாற்றுவது; முதலில் ஒரு வேரில் சுற்றுங்கள்.
- இழப்பின்றி மீள முடியும் என நினைப்பது. [JSON முதல் XML](https://toolsg.com/ta/json-to-xml) பண்புக்கூறுகளை எழுதாது; எனவே `@id` என்பது `_id` என்ற உறுப்பாகும்.

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

எதிர்த் திசைக்கு [JSON முதல் XML](https://toolsg.com/ta/json-to-xml), முடிவைச் சோதிக்க/மறுவடிவமைக்க [JSON வடிவமைப்பி](https://toolsg.com/ta/json-formatter), உலாவ [JSON பார்வையாளர்](https://toolsg.com/ta/json-viewer), பதிவுகளைத் தட்டையாக்க [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/) — Well-formedness rules, root element, attributes, predefined entities, mixed content.
- [IETF — RFC 8259, The JSON Data Interchange Format](https://www.rfc-editor.org/rfc/rfc8259.html) — The JSON output.
- [MDN — DOMParser](https://developer.mozilla.org/en-US/docs/Web/API/DOMParser) — The browser parser the converter relies on.
