XML’den JSON’a dönüştürme: kurallar, tuzaklar ve kod örnekleri

Bir SOAP uç noktasından, bir RSS akışından veya bir sitemap.xml dosyasından bir yanıt çekersiniz ve bu XML’dir. Yığınınız ise JSON tabanlıdır: ön uçta JavaScript, ortada REST, en altta bir belge deposu. Yani XML’i JSON’a dönüştürmeniz gerekir ve bunun tek satırlık bir iş olmasını bekleyerek bir ayrıştırıcıya uzanırsınız.

Çoğu zaman öyledir de — ta ki çıktı sizi ısırana kadar. Beklediğiniz bir dizinin aslında tek bir nesne olduğu ortaya çıkar. Bir id özniteliği ortadan kaybolur. 01234 gibi bir posta kodu, 1234 sayısı olarak geri döner. Bunlar ayrıştırıcınızın hataları değil; birbirine uymayan iki veri modelini eşlemenin doğal sonucudur. XML’i güvenilir şekilde JSON’a dönüştürmenin tek yolu da bu boşluğu kapatan kuralları anlamaktan geçer.

Bu rehber, bu kuralların neden var olduğunu, dönüştürmenin dört yolunu (tarayıcı, JavaScript, Python, CLI), her büyük kütüphanenin paylaştığı @_ ve #text kurallarını, sessiz veri kaybına yol açan beş tuzağı ve temiz bir gidiş-dönüş için JSON’u tekrar XML’e nasıl dönüştüreceğinizi kapsar. Örnekler gerçek ve çalıştırılabilir — bunları Node, Python veya bir kabuğa yapıştırın, yorumlarda gösterilen çıktıyı üretsinler.

XML’den JSON’a neden kurallar gerekir (yalnızca yeniden biçimlendirme değil)

XML ve JSON yüzeysel olarak benzer görünür — her ikisi de adlandırılmış, iç içe geçmiş veri ağaçlarıdır — ama temel modelleri birkaç can alıcı noktada ayrışır. XML öğeleri öznitelik taşıyabilir, karışık içerik tutabilir (alt öğelerle iç içe geçmiş metin) ve ad alanları altında yaşayabilir. JSON’da bu kavramların hiçbiri yoktur. JSON’un yalnızca nesneleri, dizileri ve dört skaler türü vardır. Birini diğerine dönüştürmek yeniden biçimlendirme değildir; birinin telaffuz edemediği sözcükleri öbürünün bildiği iki dil arasında çeviri yapmaktır.

Herhangi bir şeyi dönüştürmeden önce, kaynağın gerçekten geçerli olduğunu doğrulamak işe yarar. Kaçış uygulanmamış başıboş bir & ya da eşleşmeyen bir etiket, ayrıştırıcıda reddedilir; bu yüzden girişi önce bir XML Biçimlendirici üzerinden geçirip iyi biçimli olup olmadığını kontrol etmek, bir tur kafa karıştırıcı hatadan sizi kurtarır.

İşte iki modelin birbirinden ayrıldığı yer:

Boyut	XML	JSON
Düğüm türleri	öğeler, öznitelikler, metin, karışık içerik	nesneler, diziler, dize, sayı, boole, null
Kök kısıtlaması	tam olarak bir kök öğe gerekir	kök kısıtlaması yok
Öznitelikler	var (`id="P01"`)	yok (bir `@_` kuralı gerekir)
Tekrarlanan öğeler	aynı adlı kardeşler yasaldır	nesne anahtarları tekrarlanamaz (bir dizi kuralı gerekir)
Tür sistemi	metin türsüzdür — her şey bir karakter dizisidir	yerel türler
Ad alanları	var (`xmlns`)	yok

Modeller eşleşmediğinden, her XML’den JSON’a dönüşüm kural odaklıdır, kayıpsız bir yeniden biçimlendirme değildir. İyi haber şu ki kurallar keyfi değildir: fast-xml-parser (Node.js), xmltodict (Python) ve JAXB (Java) aynı iki işarette birleşmiştir — öznitelikler için @_, karışık içerik metni için #text. Bunları bir kez öğrenin, çalışma zamanları arasında aktarılırlar. Aynı nedenden ötürü veri biçimi uyumsuzlukları diğer dönüşümlerde de ortaya çıkar; örneğin CSV’den JSON’a dönüştürme rehberi’ndeki tür çıkarımı soruları gibi.

XML’i JSON’a dönüştürmenin 4 yöntemi

Bağlamınıza uyan yöntemi seçin: hızlı bir tek seferlik yapıştırma, bir Node servisi, bir Python iş hattı veya CI’da bir kabuk betiği.

Yöntem 1 — Tarayıcı tabanlı araç (sıfır kurulum, gizlilik öncelikli)

Tek seferlik bir dönüşüm için ya da rastgele bir web sitesine yapıştırmak istemediğiniz XML için, tarayıcı içi bir dönüştürücü en hızlı yoldur. XML’i XML’den JSON’a Dönüştürücü’ye yapıştırın, JSON anında belirsin — kurulum yok, hesap yok, yükleme yok. Her şey tarayıcınızın JavaScript motorunda çalışır, böylece veri makineden hiç ayrılmaz.

Bu son ayrıntı kulağa geldiğinden daha önemli. SOAP zarflarında WS-Security token’ları, dahili yapılandırmalarda bağlantı dizeleri, dışa aktarımlarda müşteri kayıtları olur. Dışarı hiçbir şey gitmediği için, araç kimlik bilgileri veya hassas payload içeren XML’de bile güvenlidir. İsterseniz kendiniz doğrulayın: Ağ sekmesini açın ve dönüştürürken tek bir isteğin bile gitmediğini görün.

Yöntem 2 — JavaScript / Node.js (fast-xml-parser)

Node’da fast-xml-parser standart tercihtir. Yine de varsayılanlar sizi şaşırtacaktır — öznitelikler yok sayılır ve değerler türe zorlanır — bu yüzden aşağıdaki seçenekler, sadık bir dönüşüm için gerçekten istediğiniz olanlardır:

// fast-xml-parser kullanarak Node.js'te XML'i JSON'a dönüştürün
import { XMLParser } from 'fast-xml-parser';

const xml = `<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>`;

const parser = new XMLParser({
  ignoreAttributes: false,    // öznitelikleri koru (varsayılan onları atar!)
  attributeNamePrefix: '@_',  // öznitelikler @_ önekli anahtarlara dönüşür
  textNodeName: '#text',      // karışık içerik metni #text altına gider
  parseAttributeValue: false, // özniteliklerde tür zorlaması yok
  parseTagValue: false,       // öğe metninde tür zorlaması yok
});

const result = parser.parse(xml);
console.log(JSON.stringify(result, null, 2));
// {
//   "catalog": {
//     "product": {
//       "@_id": "P01",
//       "name": "Wireless Headphones",
//       "price": {
//         "@_currency": "USD",
//         "#text": "79.99"
//       }
//     }
//   }
// }

İnsanların unuttuğu iki ayar ignoreAttributes: false ve parseTagValue: false’dur. İlki id ve currency özniteliklerinizi korur; ikincisi ayrıştırıcının "79.99"’u bir kayan sayıya ve "01234"’ü 1234’e çevirmesini durdurur. Tuzaklar bölümünde dize korumasının neden güvenli varsayılan olduğuna geri döneceğiz.

Tarayıcıda sıfır bağımlılık istiyorsanız, yerel DOMParser ayrıştırmayı sizin için yapar ve siz DOM’u kendiniz dolaşırsınız:

// DOMParser kullanarak tarayıcıda sıfır bağımlılıklı XML'den JSON'a
function xmlToJson(node) {
  // Yalnızca metin içeren öğe → dize değeri
  const children = Array.from(node.children);
  if (children.length === 0 && node.attributes.length === 0) {
    return node.textContent.trim();
  }

  const obj = {};
  // Öznitelikler → @_ öneki
  for (const attr of node.attributes) {
    obj['@_' + attr.name] = attr.value;
  }
  // Hem öznitelik HEM metin içeren öğe → #text
  if (children.length === 0) {
    obj['#text'] = node.textContent.trim();
    return obj;
  }
  // Alt öğelere yinele, aynı adlı kardeşleri dizilerde topla
  for (const child of children) {
    const value = xmlToJson(child);
    if (obj[child.tagName] === undefined) {
      obj[child.tagName] = value;
    } else {
      if (!Array.isArray(obj[child.tagName])) obj[child.tagName] = [obj[child.tagName]];
      obj[child.tagName].push(value);
    }
  }
  return obj;
}

const doc = new DOMParser().parseFromString(
  '<catalog><product id="P01"><name>Wireless Headphones</name></product></catalog>',
  'text/xml'
);
const json = { [doc.documentElement.tagName]: xmlToJson(doc.documentElement) };
console.log(JSON.stringify(json, null, 2));
// { "catalog": { "product": { "@_id": "P01", "name": "Wireless Headphones" } } }

DOMParser XML 1.0 uyumludur, CDATA’yı ve varlık başvurularını işler ve iyi biçimlilik hatalarını bildirir — hepsi de bir paket kurulumu olmadan. Bedeli, yukarıda gösterilen dizi toplama kuralı dahil dolaşma mantığının size ait olmasıdır.

Yöntem 3 — Python (xmltodict)

Python’da xmltodict tüm işi kısa bir iş hattına indirir. Varsayılan olarak öznitelik öneki olarak @ ve karışık içerik için #text kullanır:

# xmltodict kullanarak Python'da XML'i JSON'a dönüştürün
import json
import xmltodict

xml = """<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>"""

data = xmltodict.parse(xml)
print(json.dumps(data, indent=2))
# {
#   "catalog": {
#     "product": {
#       "@id": "P01",
#       "name": "Wireless Headphones",
#       "price": {
#         "@currency": "USD",
#         "#text": "79.99"
#       }
#     }
#   }
# }

xmltodict varsayılan olarak her değeri bir dize olarak tutar; bu da istediğiniz davranıştır. Önceden bilinmeye değer tek seçenek force_list’tir; bu, tek-mi-çok dizi sorununu kodunuza ulaşmadan önce düzeltir:

# force_list, tek bir tane olsa bile <product>'ın her zaman bir liste olmasını garanti eder
data = xmltodict.parse(xml, force_list={'product'})
products = data['catalog']['product']  # artık her zaman bir liste
for p in products:
    print(p['name'])

force_list olmadan, bir <product> bir sözlük, iki tane ise bir liste verir — ve döngünüz tek öğeli durumda çöker. Bu, aşağıda ele aldığımız 1 numaralı tuzaktır.

Yöntem 4 — CLI (yq / Python tek satırlık)

Kabuk betikleri ve CI iş hatları için iki tek satırlık komut çoğu durumu kapsar. Mike Farah’nın yq’si XML okur ve doğrudan JSON yayar:

# yq kullanarak (Mike Farah'nın Go sürümü)
yq -p=xml -o=json '.' input.xml

# stdin'den boru ile geçir
cat sitemap.xml | yq -p=xml -o=json '.'

Ortamınızda xmltodict zaten varsa, Python tek satırlık komutu ek bir ikili dosya gerektirmez:

python3 -c "import sys, xmltodict, json; print(json.dumps(xmltodict.parse(sys.stdin.read()), indent=2))" < input.xml

Her ikisi de stdin’den akar, böylece doğrudan bir iş hattına düşerler — bir betiğin ortasında bir API yanıtını dönüştürmek veya bir derleme adımında bir dosya yığınını normalleştirmek için kullanışlıdır.

@_ özniteliği ve #text kuralları açıklandı

Çoğu dönüştürücü sayfası işin can alıcı yerini atlar: o tuhaf @_ ve #text anahtarları ne anlama gelir, neden vardır. Bir kez kavradığınızda çıktı artık keyfi görünmez.

Öznitelikler @_ önekli anahtarlara eşlenir. Bir özniteliğin JSON karşılığı yoktur — bir nesnede, bir alt öğeden ayrı olarak “bu nesne hakkında üst veri” için bir yuva bulunmaz. Kural, özniteliklere @_ önekli bir anahtar vermektir:

<user id="42" role="admin"/>
→ { "user": { "@_id": "42", "@_role": "admin" } }

Neden özellikle @_? Çünkü geçerli hiçbir XML öğe adı @ ile başlayamaz, bu yüzden önek gerçek bir alt öğe anahtarıyla asla çakışamaz. Bu, göz önünde saklanan ayrılmış bir ad alanıdır. (xmltodict yalın @ kullanır; fast-xml-parser varsayılan olarak @_ kullanır. İlke aynıdır.)

Karışık içerik #text’e eşlenir. Bir öğenin hem bir özniteliği hem de bir metin değeri olduğunda, metnin öznitelik anahtarlarının yanında yaşayacağı bir yere ihtiyacı vardır. İşte bu #text’tir:

<price currency="USD">29.99</price>
→ { "price": { "@_currency": "USD", "#text": "29.99" } }

Düz metin öğeleri doğrudan bir dize değeri olur. Öznitelik yok, alt öğe yok, yalnızca metin — bu yüzden #text dolaylamasına gerek yoktur. <name>Alice</name>, "name": "Alice" olur. #text anahtarı yalnızca öznitelikler öğe değerini bir nesne olmaya zorladığında ortaya çıkar.

Bu asimetri, ince bir hatanın kaynağıdır. Aynı öğe adı, o belirli örneğin bir öznitelik taşıyıp taşımadığına bağlı olarak bir belgede düz bir dize, başka bir belgede ise bir @_/#text nesnesi üretebilir. currency özniteliği olmayan bir <price>, "29.99" dizesidir; aynı <price currency="USD"> ise { "@_currency": "USD", "#text": "29.99" }’dur. node.price’ı doğrudan okuyan kod bir biçim için çalışır ve diğerinde sessizce bozulur. Savunmacı erişimci, türü kontrol etmektir: const amount = typeof node.price === 'object' ? node.price['#text'] : node.price;.

CDATA, düz metin içeriği olur. Bir <![CDATA[if (a < b) return;]]> bölümü yalnızca bir kaçış mekanizmasıdır, bu yüzden sınırlayıcılar çıkarılır ve içteki metin korunur: "if (a < b) return;". JSON’a özel hiçbir şey hayatta kalmaz.

Çıktıyı elde ettiğinizde, JSON çıktısını doğrulamak ve yapının tüketicinizin beklediğiyle eşleştiğini kodla ilişkilendirmeden önce onaylamak için bir JSON Biçimlendirici’ye yapıştırın.

5 XML’den JSON’a tuzak ve bunlardan kaçınma yolları

Bunlar, kod incelemesini atlatıp üretimde ortaya çıkan hatalardır. Her biri, bu rehberin başındaki model uyumsuzluğuna geri dayanır.

1. Dizi belirsizliği (tek mi çok mu). Tek bir <item> bir nesne olur; iki veya daha fazlası bir dizi olur. JSON biçimi, o belirli belgede kaç kardeşin bulunduğuna bağlıdır. result.items.item.forEach(...) gibi tüketici kodu testte çalışır — burada fikstürünüzde üç öğe vardır — ve bir kayıtta tam olarak bir öğe olduğunda üretimde TypeError: not a function fırlatır.

// İki <book> kardeşi → dizi
// <library><book>A</book><book>B</book></library>
// → { "library": { "book": ["A", "B"] } }

// Tek <book> → nesne, dizi DEĞİL
// <library><book>A</book></library>
// → { "library": { "book": "A" } }

// Her iki durum da aynı şekilde davranacak biçimde normalleştir
const books = [].concat(result.library?.book ?? []);
books.forEach(b => console.log(b)); // 0, 1 veya çok sayıda için güvenli

[].concat(x ?? []) deyimi ezberlenmeye değer: eksik bir değer [] olur, tek bir nesne [object] olur ve var olan bir dizi değişmeden geçer. Python’da xmltodict.parse()’a force_list={'book'} geçirin, değer her zaman bir liste olur, böylece normalleştirmeyi tamamen atlarsınız.

2. Öznitelikler sessizce atılır. Birkaç kütüphane öznitelikleri yok saymaya varsayılan olarak ayarlanmıştır — fast-xml-parser, siz ignoreAttributes: false ayarlayana kadar tam olarak bunu yapar. Dönüşüm işe yaramış gibi görünür, JSON sorunsuz ayrıştırılır ve id, currency ve status değerleriniz basitçe yok olur. Varsayılana güvenmek yerine bayrağı her zaman açıkça ayarlayın.

3. Ad alanı düzleştirmesi. Bir xmlns bildirimi sıradan bir @_xmlns anahtarı olur ve <soap:Body>’deki önek yalnızca "soap:Body" dize anahtarının bir parçası olarak hayatta kalır. Anlam bilimi — iki önekin aynı URI’ye bağlanabileceği — kaybolur.

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>...</soap:Body>
</soap:Envelope>
→ {
    "soap:Envelope": {
      "@_xmlns:soap": "http://schemas.xmlsoap.org/soap/envelope/",
      "soap:Body": "..."
    }
  }

soap: öneki artık bir anahtar adındaki yalnızca metindir; hiçbir şey bunun bir ad alanı olduğunu bilmez. Farklı ad alanlarından iki öğe yerel bir adı paylaşırsa, çakışabilirler. Kesin ad alanı işleme gereksinimin bir parçası olduğunda, veriyi ad alanı duyarlı bir ayrıştırıcıda tutun ve onu JSON’a hiç düzleştirmeyin.

4. Tür zorlaması yok — ve bu doğru. <zip>01234</zip>, 1234 olmamalıdır. Hesap kodları, posta kodları, dolgulanmış tanımlayıcılar ve hassasiyete duyarlı ondalıklar, sessiz zorlama altında bozulur. İyi bir dönüştürücü her şeyi bir dize olarak tutar ve kasıtlı olarak zorlamanıza izin verir:

// Örtük zorlamaya güvenmeyin
if (config.timeout > 25) { /* kırılgan: "30" > 25 tesadüfen işe yarar */ }

// Açıkça zorlayın, yalnızca türü bildiğiniz yerde
if (parseInt(config.timeout, 10) > 25) { /* güvenli */ }

5. Kayıplı: yorumlar, işleme yönergeleri ve karışık içerik sırası. XML yorumları () ve işleme yönergeleri (<?xml-stylesheet ?>) için JSON’da bir ev yoktur ve atılırlar. Alt öğelerle iç içe geçmiş metnin göreli sırası gidiş-dönüşte korunmayabilir. Her baytın korunmasına ihtiyacınız varsa — tam kaynak belgeyi yeniden yaymak için — hiç dönüştürmeyin; veri modeline dokunmadan yeniden biçimlendirmek veya küçültmek için bir XML Biçimlendirici kullanın.

JSON’u tekrar XML’e dönüştürme (gidiş-dönüş)

Diğer yöne gitmenin kendine özgü bir kıvrımı vardır, çünkü JSON’da kök öğe kuralı yoktur ve XML tam olarak bir tane gerektirir. Eşlik eden JSON’dan XML’e Dönüştürücü, aynı @_/#text kurallarını tersine uygular, böylece bir JSON → XML → JSON gezisi öznitelikleri, metni ve yapıyı korur.

İlginç olan kısım kök normalleştirmesidir. Dönüştürücü, tek kök gereksinimini dört kuralla çözer:

Tek anahtarlı nesne → o anahtar kök olur: { "config": {...} } → <config>...</config>.
Çok anahtarlı nesne → <root> içine sarılır: { "a": 1, "b": 2 } → <root><a>1</a><b>2</b></root>.
Üst düzey dizi → <root><item>...</item></root> olarak sarılır, sabit bir geri dönüş adı olarak <item> ile.
İlkel değer → <root>value</root>.

Geri kalan her şey ileri yönü yansıtır. @_ anahtarları öznitelik olur, #text metin içeriği olur ve bir anahtar altındaki bir JSON dizisi, aynı adlı tekrarlanan kardeşler üretir — anahtar adı yeniden kullanılır, asla tekilleştirilmez:

// fast-xml-parser kullanarak Node.js'te JSON'u XML'e dönüştürün
import { XMLBuilder } from 'fast-xml-parser';

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

const builder = new XMLBuilder({
  attributeNamePrefix: '@_', // @_ anahtarları öznitelik olur
  textNodeName: '#text',     // #text anahtarı metin içeriği olur
  ignoreAttributes: false,   // @_ anahtarlarını işle
  format: true,              // güzel biçimlendir
});

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

Oluşturucunun sizin için işlediği bir ayrıntı: metin ve öznitelik değerlerindeki özel karakterler (<, >, &, ") varlık başvurularına kaçış uygulanır, böylece çıktı iyi biçimli kalır.

SSS

XML öznitelikleri JSON’a nasıl eşlenir?

Öznitelikler @_ önekli anahtarlar olur, böylece id="42", "@_id": "42"’ye dönüşür. Bu, fast-xml-parser ve xmltodict’in paylaştığı kuraldır ve önek öğe adlarıyla asla çakışmaz çünkü geçerli hiçbir öğe adı @ ile başlamaz.

XML’den JSON’a dönüşüm sayıları neden dize olarak tutar?

Çünkü dönüştürücü hiçbir tür zorlaması yapmaz. 01234’ü 1234’e zorlamak, posta kodlarından, hesap numaralarından ve dolgulanmış kimliklerden anlamlı bir baştaki sıfırı düşürür. Her değeri bir dize olarak tutmak güvenli varsayılandır; türü bildiğiniz yerde aşağı akışta kasıtlı olarak zorlayın.

XML’den JSON’a dönüşüm kayıpsız mıdır?

Hayır. Yorumlar ve işleme yönergeleri atılır, ad alanı anlam bilimi yalnızca kısmen korunur ve karışık içerik sıralaması gidiş-dönüşte korunmayabilir. Her baytın korunmasına ihtiyacınız olduğunda, XML’i JSON’a dönüştürmek yerine yeniden biçimlendirmek için bir XML Biçimlendirici kullanın.

Tekrarlanan XML öğeleri JSON’da nasıl işlenir?

Tek bir aynı adlı alt öğe bir nesne olur; iki veya daha fazlası bir dizi olur. Biçim kardeş sayısına bağlı olduğundan, tüketici kodunuz tek öğeli ve çok öğeli durumların ikisini de çökmeden işlemesi için her zaman bir diziye normalleştirmelidir.

JSON’a dönüştürürken XML ad alanlarına ne olur?

Bir xmlns bildirimi sıradan bir @_xmlns anahtarı olur ve önek, "soap:Body"’de olduğu gibi öğe adı dizesinin içinde kalır. Bir önekin bir URI’ye anlamsal bağlanması yorumlanmaz, bu yüzden farklı ad alanları bir arada düzleşebilir.

JSON’u tekrar XML’e nasıl dönüştürürüm?

Eşlik eden JSON’dan XML’e Dönüştürücü’yü kullanın. Aynı @_ ve #text kurallarını tersine uygular, böylece öznitelikler, metin içeriği ve diziler simetrik olarak geri eşlenir. Temiz bir JSON → XML → JSON gidiş-dönüşünü mümkün kılan da bu simetridir.

Birden çok kök öğesi olan XML’i dönüştürebilir miyim?

Hayır. Birden çok üst düzey öğe iyi biçimli XML değildir, bu yüzden ayrıştırıcı girişi reddeder. Önce parçaları tek bir kök öğeyle sarın — <a/><b/>’yi <root><a/><b/></root> haline getirin — sonra dönüştürün.

Sonuç

XML’den JSON’a dönüşüm kural odaklıdır, bir yeniden biçimlendirme değildir. Kurallar çalışma zamanları arasında tutarlıdır: öznitelikler @_ anahtarlarına eşlenir, karışık içerik metni #text’e, tekrarlanan kardeşler dizilere ve değerler dize kalır, böylece baştaki sıfırlar ve hassasiyet hayatta kalır. Akılda tutulacak tuzaklar tek-mi-dizi-mi biçim kayması, sessizce atılan öznitelikler, kaybolan yorumlar ve ad alanı anlam bilimidir. Bunların hiçbiri hata değil; arkalarındaki model uyumsuzluğunu bildiğinizde hepsi önceden kestirilebilir.

Hızlı, gizli bir dönüşüme ihtiyacınız olduğunda, XML’den JSON’a Dönüştürücü’ye yapıştırın — tamamen tarayıcınızda çalışır. Kaynağı önce XML Biçimlendirici ile doğrulayın ve gidiş-dönüş XML’e ihtiyacınız olduğunda JSON’dan XML’e Dönüştürücü ile diğer yöne gidin. Veri biçimi modellerinin dönüşüm davranışını nasıl şekillendirdiği hakkında daha fazlası için YAML ve JSON farklılıkları üzerine notlara bakın.

XML'den JSON'a: kurallar, tuzaklar ve kod örnekleri