Konverter JSON ke XML

Apa Itu Konversi JSON-ke-XML dan Bagaimana Cara Kerjanya?

// Convert JSON to XML in Node.js using fast-xml-parser
import { XMLBuilder } from 'fast-xml-parser';

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      '@_category': 'electronics',
      name: 'Wireless Headphones',
      price: {
        '@_currency': 'USD',
        '#text': '79.99'
      }
    }
  }
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_',   // @_ keys become XML attributes
  textNodeName: '#text',       // #text key becomes element text content
  ignoreAttributes: false,     // process @_ attribute keys
  format: true,                // pretty-print with indentation
  indentBy: '  ',              // 2-space indent
});

const xml = builder.build(data);
console.log(xml);
// <catalog>
//   <product id="P01" category="electronics">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

Fitur Utama

Contoh

{"user":{"id":42,"name":"Alice Kim","email":"alice@example.com","role":"admin","address":{"city":"Seoul","country":"KR"}}}

[{"id":1,"name":"Widget A","price":9.99},{"id":2,"name":"Widget B","price":14.99},{"id":3,"name":"Widget C","price":4.49}]

{"catalog":{"product":{"@_id":"P01","@_category":"electronics","name":"Wireless Headphones","price":{"@_currency":"USD","#text":"79.99"}}}}

Cara Menggunakan

1. 1

   Tempel JSON Anda

   Masukkan atau tempel data JSON ke kolom input di atas. Anda juga dapat klik 'Muat contoh' untuk mencoba sampel — objek respons API, payload array, atau objek menggunakan atribut @_ dan #text.

2. 2

   Lihat Output XML Langsung

   XML muncul seketika di panel output. Objek dengan satu kunci menggunakan kunci sebagai root; objek dengan beberapa kunci dibungkus dalam ; kunci berprefix @_ menjadi atribut; array menjadi elemen anak berulang. Sesuaikan indent (2 atau 4 spasi) sesuai kebutuhan.

3. 3

   Salin atau Unduh

   Klik Copy untuk mengambil XML ke clipboard, atau Download untuk menyimpannya sebagai file .xml. Untuk memvalidasi atau memformat ulang hasilnya, tempel ke XML Formatter.

Jebakan Konversi Umum

// Input: { "status": 200, "data": { "id": 1 } }
// Output: <root><status>200</status><data><id>1</id></data></root>
// Root is <root> — may not match your schema

// Wrap in a named key to control the root element
// Input: { "response": { "status": 200, "data": { "id": 1 } } }
// Output: <response><status>200</status><data><id>1</id></data></response>

// Input: [{ "id": 1 }, { "id": 2 }]
// Output: <root><item><id>1</id></item><item><id>2</id></item></root>
// Tag names are generic

// Wrap in a named key for meaningful tag names
// Input: { "products": [{ "id": 1 }, { "id": 2 }] }
// Output: <root><products><id>1</id></products><products><id>2</id></products></root>
// Each array element reuses the key name "products" as its tag

// Input: { "tag": { "id": "42", "name": "Alice" } }
// Output: <tag><id>42</id><name>Alice</name></tag>  ← id is a child element

// Use @_ prefix for attributes
// Input: { "tag": { "@_id": "42", "name": "Alice" } }
// Output: <tag id="42"><name>Alice</name></tag>  ← id is an attribute

// Input: { "price": { "@_currency": "USD", "value": "29.99" } }
// Output: <price currency="USD"><value>29.99</value></price>
// Text is a child element, not text content

// Use #text for element text content
// Input: { "price": { "@_currency": "USD", "#text": "29.99" } }
// Output: <price currency="USD">29.99</price>  ← text content

// JSON key starts with digit — invalid XML element name
// Input: { "1stItem": "value" }
// Output: <1stItem>value</1stItem>  ← invalid XML

// Use a valid XML element name
// Input: { "firstItem": "value" }
// Output: <firstItem>value</firstItem>  ← valid XML

// JSON: { "query": "name = 'Alice' & role = 'admin'" }
// Converter outputs: <query>name = 'Alice' &amp; role = 'admin'</query>
// If double-processed: &amp;amp; — consumer is re-escaping

// Converter output is correct — consume it as XML, not as a raw string
// <query>name = 'Alice' &amp; role = 'admin'</query>
// XML parser decodes to: name = 'Alice' & role = 'admin'

Kasus Penggunaan Umum

Memanggil Layanan Web SOAP dan XML Lama

Bangun payload JSON di aplikasi Anda, konversi ke XML, dan POST ke endpoint SOAP. Ini menghindari pembuatan string XML secara manual dan memungkinkan Anda bekerja dengan data dalam struktur JSON native hingga saat Anda perlu menserialisasinya untuk layanan lama.

Menghasilkan File Konfigurasi XML

Spring, Maven, Ant, Tomcat, dan Android semuanya menggunakan format konfigurasi XML. Hasilkan atau transformasikan data konfigurasi sebagai JSON — lebih mudah di-diff dan dikontrol versi — lalu konversi ke XML untuk deployment.

Menghasilkan Sitemap dan Feed RSS XML

Sistem manajemen konten dan generator situs statis sering menyimpan metadata halaman sebagai JSON. Konversi metadata tersebut ke sitemap.xml atau feed RSS XML untuk diserahkan ke mesin pencari atau menyindikasikan konten ke pembaca feed.

Integrasi Data Enterprise (EDI / ERP / CRM)

Sistem ERP (SAP, Oracle), platform CRM, dan jaringan EDI biasanya bertukar data dalam XML. Konversi ekspor JSON dari REST API modern ke XML untuk memberi makan sistem-sistem ini tanpa membangun serializer XML kustom.

File Resource Android

Resource string Android, batasan layout, dan entri manifest semuanya adalah XML. Hasilkan atau perbarui file resource secara programatik dari sumber data JSON dan konversi ke format XML yang diperlukan oleh sistem build Android.

Pembuatan SVG dan Grafis Vektor

SVG adalah XML. Bangun struktur SVG sebagai data JSON — path, bentuk, warna, transformasi — lalu konversi ke XML untuk menghasilkan file SVG yang valid untuk web, cetak, atau alat pengeditan vektor.

Detail Teknis

Parsing JSON Sesuai RFC 8259

Input JSON di-parse menggunakan JSON.parse() bawaan browser, yang sepenuhnya sesuai RFC 8259. Ini memberikan pesan error sintaks yang akurat dengan informasi posisi best-effort (baris dan kolom) dan menangani semua tipe data JSON: string, angka, boolean, null, array, dan objek.

Serializer JSON-ke-XML Rekursif Kustom

Setelah di-parse, serializer rekursif kustom menelusuri pohon JSON. Kunci objek yang dimulai dengan @_ dikeluarkan sebagai atribut XML pada elemen induk. Kunci #text dikeluarkan sebagai konten teks elemen. Kunci objek biasa menjadi elemen anak. Nilai array menghasilkan elemen saudara berulang dengan nama yang sama. Karakter khusus (<, >, &, ", ') dalam konten teks dan nilai atribut di-escape ke referensi entitas XML-nya.

Normalisasi Root

Karena XML memerlukan tepat satu elemen root, serializer menerapkan normalisasi root sebelum membangun dokumen: objek dengan satu kunci menggunakan kunci sebagai root; objek dengan beberapa kunci dan array tingkat atas menerima pembungkus sintetis. Ini memastikan output selalu XML well-formed terlepas dari bentuk input.

100% Berbasis Browser — Tanpa Upload, Tanpa Server

Semua pemrosesan berjalan di JavaScript engine browser Anda. Tidak ada data yang ditransmisikan melalui jaringan kapan pun. Input yang lebih besar dari 200KB secara otomatis beralih dari mode langsung ke mode manual (memerlukan klik Convert eksplisit) untuk menjaga browser tetap responsif selama serialisasi berat.

Praktik Terbaik

Kontrol Elemen Root dengan Objek Satu Kunci

Cara paling bersih untuk menghasilkan XML yang bermakna adalah memastikan JSON tingkat atas Anda adalah objek dengan satu kunci yang merupakan nama elemen root yang diinginkan. Membungkus data multi-kunci di bawah satu kunci bernama memberikan root yang bermakna secara semantis alih-alih pembungkus generik .

Gunakan @_ dan #text untuk XML yang Banyak Menggunakan Atribut

Jika skema XML target Anda menggunakan banyak atribut (umum dalam file konfigurasi, SVG, dan SOAP envelope), bentuk ulang JSON Anda untuk menggunakan kunci berprefix @_ dan #text sebelum mengonversi. XML yang dihasilkan akan cocok dengan skema target persis tanpa pasca-pemrosesan.

Bungkus Array dalam Objek Bernama untuk Nama Tag yang Bermakna

Array tingkat atas menghasilkan pola generik ..., di mana adalah nama literal tetap. Membungkus array di bawah kunci bernama — { "products": [...] } — menghasilkan elemen berulang (nama kunci digunakan kembali untuk setiap elemen array) di bawah pembungkus . Ini memberikan nama tag yang bermakna secara domain dan hampir selalu lebih disukai untuk XML yang akan di-parse atau divalidasi oleh skema.

Validasi Output dengan XML Formatter

Setelah mengonversi, tempel output XML ke XML Formatter untuk memvalidasi well-formedness, memeriksa indentasi, dan mengidentifikasi masalah struktural apa pun sebelum mengirim XML ke layanan hilir atau melakukan commit ke version control.

Sanitasi Kunci JSON Sebelum Mengonversi

Nama elemen XML harus dimulai dengan huruf atau garis bawah dan tidak boleh mengandung spasi atau sebagian besar karakter khusus. Jika kunci JSON Anda berasal dari sumber eksternal (nama kolom database, nama field API, atau input pengguna), audit untuk validitas nama XML sebelum mengonversi guna menghindari output yang tidak valid.

Pertanyaan yang Sering Diajukan