# Pemetaan XML ke JSON: atribut, elemen berulang dan apa yang dibuang

> Pemetaan tepat yang digunakan penukar ini: @ untuk atribut, #text untuk teks di sebelah atribut, tatasusunan hanya untuk nama berulang, setiap nilai ialah rentetan, dan teks kandungan bercampur, komen serta pengisytiharan dibuang.

- Tool: [Penukar XML ke JSON](https://toolsg.com/ms/xml-to-json)
- Language: ms (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.

## Angka utama sepintas lalu

| Perkara | Nilai | Sumber |
| --- | --- | --- |
| Atribut | Kunci berawalan @ (contohnya "@id") — Pengisytiharan ruang nama juga atribut, jadi xmlns:ns muncul sebagai "@xmlns:ns". |  |
| Teks di sebelah atribut | Disimpan di bawah kunci "#text" — Elemen daun tanpa atribut menjadi rentetan biasa. |  |
| Elemen berulang | Menjadi tatasusunan hanya apabila nama muncul lebih daripada sekali — Satu <item> memberi objek atau rentetan; dua memberi tatasusunan. |  |
| Jenis nilai | Sentiasa rentetan — 12.50 kekal "12.50"; true kekal "true". |  |

## Cara penukaran berfungsi

Halaman menyerahkan teks anda (dengan ruang kosong awal dan akhir dibuang) kepada `DOMParser` pelayar sebagai `application/xml`. Jika pelayar melaporkan ralat penghuraian, anda melihat mesej tetap "Itu bukan XML yang terbentuk dengan baik."; butiran (baris, lajur, sebab) tidak dipaparkan. Jika tidak, elemen akar menjadi satu-satunya kunci peringkat atas, dan setiap elemen ditukar kepada nilai JSON mengikut peraturan ini, yang disemak pada halaman sebenar:

| XML | JSON |
| --- | --- |
| `<a><b>Mei</b></a>` | `{"a":{"b":"Mei"}}` |
| `<a/>` atau `<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"/>` | kunci `"ns:a"` dengan `"@xmlns:ns"` dan `"@ns:id"` |

Output diinden dua ruang. Semua nilai ialah rentetan: penukar tidak pernah meneka nombor atau boolean, jadi `12.50` mengekalkan sifar di hujungnya.

## Contoh

```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" }
    ]
  }
}
```

(Halaman mencetak setiap objek merentasi beberapa baris.) Dengan hanya satu `<person>`, laluan yang sama ialah objek, bukan tatasusunan satu item.

## Apa yang hilang

- **Kandungan bercampur**: dalam `<a>text<b>bold</b>more</a>` hanya `{"a":{"b":"bold"}}` yang kekal; nod teks `text` dan `more` dibuang apabila elemen mempunyai elemen anak.
- **Teks elemen yang mempunyai anak dan atribut** juga dibuang; hanya atribut dan anak dikekalkan.
- **Komen dan arahan pemprosesan** diabaikan, dan pengisytiharan XML tidak diwakili.
- **Susunan antara nama berbeza**: adik-beradik dikumpulkan mengikut nama, jadi `b, c, b` menjadi `b: [..], c`. Selang-seli tidak dapat dipulihkan.
- **CDATA** digabungkan ke dalam teks biasa: `<![CDATA[1 < 2 & 3]]>` menjadi rentetan `1 < 2 & 3`. Entiti dinyahkod (`&amp;&lt;&#65;` memberi `&<A`).
- **Ruang kosong**: inden antara elemen anak diabaikan, tetapi elemen teks sahaja mengekalkan ruangnya, jadi `<a>  </a>` memberi `"  "`.

## Ralat dan kekerasan

XML lebih ketat daripada HTML. Pelayar menolak: lebih daripada satu akar (`<a/><b/>`), tag tidak sepadan (`<a><b>1</a>`), nilai atribut tanpa petikan (`<a b=1/>`), atribut berulang pada satu tag, nama bermula dengan digit (`<1/>`), dan entiti yang tidak ditakrifkan spesifikasi XML seperti `&nbsp;` (hanya `amp`, `lt`, `gt`, `apos` dan `quot` yang dipratakrif). Teks biasa yang bukan XML juga ditolak. Input kosong memberi output kosong tanpa ralat.

Entiti DOCTYPE dalaman dikendalikan oleh penghurai pelayar (dalam ujian, `<!DOCTYPE a [<!ENTITY e "hi">]><a>&e;</a>` menghasilkan `"hi"`), jadi hasil dokumen yang banyak DOCTYPE bergantung pada pelayar. Jangan tampal XML tidak dipercayai dengan DTD dan menjangka kelakuan seragam.

> **Petua:** Oleh sebab satu anak memberi objek dan beberapa anak memberi tatasusunan, kod yang menggunakan JSON mesti mengendalikan kedua-dua bentuk. Jika anda mengawal XML, elemen pembungkus yang konsisten menjadikan JSON lebih mudah digunakan; jika tidak, normalkan dalam kod (bungkus bukan tatasusunan dalam tatasusunan).

## Kesilapan biasa

- Menganggap `"@id"` dan `"#text"` sebagai sebahagian daripada data anda. Ia konvensyen alat ini; penukar lain menggunakan `_attributes`, `$` atau `attr_`.
- Menjangka nombor atau boolean: setiap nilai ialah teks.
- Menukar serpihan XML dengan beberapa elemen peringkat atas; bungkus dalam satu akar dahulu.
- Menganggap pusingan penuh selamat. [JSON ke XML](https://toolsg.com/ms/json-to-xml) tidak menulis atribut, jadi `@id` menjadi elemen bernama `_id`.

## Alat berkaitan

Pergi ke arah sebaliknya dengan [JSON ke XML](https://toolsg.com/ms/json-to-xml), semak atau format semula hasilnya dengan [pemformat JSON](https://toolsg.com/ms/json-formatter), layari dalam [pemapar JSON](https://toolsg.com/ms/json-viewer), atau ratakan rekod dengan [JSON ke CSV](https://toolsg.com/ms/json-to-csv).

## Soalan lazim

**Adakah data saya dimuat naik ke mana-mana?**

Tidak. Penukaran berjalan sepenuhnya dalam pelayar anda menggunakan JavaScript. Apa yang anda tampal tidak meninggalkan peranti anda, tidak dilog dan tidak disimpan pada pelayan.

**Sebesar mana dokumen yang boleh dikendalikan?**

Hadnya ialah memori pelayar anda dan bukan kuota pelayan. Dokumen beberapa megabait ditukar tanpa masalah; fail yang sangat besar mungkin menyebabkan halaman tidak bertindak balas seketika.

**Apa yang berlaku kepada data bersarang?**

Format yang tiada konsep sarang menyimpan nilai bersarang sebagai rentetan JSON di dalam sel, jadi tiada apa yang dibuang secara senyap dan strukturnya boleh dipulihkan.

**Adakah ia mengendalikan petikan dan koma dalam medan?**

Ya. Penghuraian mengikut RFC 4180, jadi medan berpetik yang mengandungi koma, petikan berganda yang dilepaskan, dan pemisah baris di dalam medan semuanya dibaca dan ditulis dengan betul.


## Sumber rujukan

- [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.
