Konwerter XML na JSON

Czym jest konwersja XML na JSON i jak działa?

// Convert XML to JSON in Node.js using fast-xml-parser
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,      // preserve attributes
  attributeNamePrefix: '@_',    // @_ prefix for attributes
  textNodeName: '#text',        // #text for mixed element content
  parseAttributeValue: false,   // no type coercion on attributes
  parseTagValue: false,         // no type coercion on element text
});

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"
//       }
//     }
//   }
// }

Kluczowe funkcje

Przykłady

<?xml version="1.0" encoding="UTF-8"?>
<appConfig version="2.1" env="production">
  <database>
    <host>db.example.com</host>
    <port>5432</port>
    <name>myapp_prod</name>
    <pool max="10" min="2"/>
  </database>
  <cache enabled="true">
    <ttl>3600</ttl>
    <driver>redis</driver>
  </cache>
</appConfig>

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://go-tools.org/tools/xml-to-json</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
  <url>
    <loc>https://go-tools.org/tools/json-to-xml</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

<item>
  <title>XML to JSON: A Practical Guide</title>
  <link>https://go-tools.org/blog/xml-to-json-guide</link>
  <pubDate>Thu, 29 May 2026 00:00:00 GMT</pubDate>
  <category>Developer Tools</category>
  <description>Learn how XML attributes map to @_ keys, how repeated elements become arrays, and why values stay strings in any XML-to-JSON conversion.</description>
  <guid isPermaLink="true">https://go-tools.org/blog/xml-to-json-guide</guid>
</item>

Jak używać

1. 1

   Wklej dane XML

   Wprowadź lub wklej XML do pola wejściowego powyżej. Możesz też kliknąć «Wczytaj przykład», aby wypróbować próbkę — plik konfiguracyjny, fragment mapy strony lub element RSS.

2. 2

   Zobacz wynik JSON na żywo

   JSON pojawia się natychmiast w panelu wyjściowym. Atrybuty stają się kluczami z prefiksem @_, treść tekstowa elementów mieszanych staje się #text, a powtarzające się elementy siostrzane stają się tablicami. Dostosuj wcięcie (2 lub 4 spacje) według potrzeb.

3. 3

   Kopiuj lub pobierz

   Kliknij Kopiuj, aby przenieść JSON do schowka, lub Pobierz, aby zapisać jako plik .json gotowy do użycia w aplikacji, API lub potoku danych.

Typowe problemy przy konwersji

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }  ← string, not number
// Dangerous: comparing as-is
if (config.timeout > 25) { ... }  // "30" > 25 coerces, but fragile

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }
// Safe: explicit coercion where you know the type
if (parseInt(config.timeout, 10) > 25) { ... }

// XML with one item: <root><item>a</item></root>
// JSON: { "root": { "item": "a" } }  ← string, not array
result.root.item.forEach(i => console.log(i));  // TypeError: not a function

// Normalize to array regardless of count
const items = [].concat(result.root?.item ?? []);
items.forEach(i => console.log(i));  // safe for 0, 1, or many

// XML: <price currency="USD">29.99</price>
// JSON: { "price": { "@_currency": "USD", "#text": "29.99" } }
const amount = result.price;  // { "@_currency": "USD", "#text": "29.99" }, not "29.99"

// Handle both plain string and @_/#text object
const raw = result.price;
const amount = typeof raw === 'object' ? raw['#text'] : raw;  // "29.99"

<!-- Unescaped & — well-formedness error -->
<query>name = 'Alice' & role = 'admin'</query>

<!-- Escaped & — valid XML -->
<query>name = 'Alice' &amp; role = 'admin'</query>

// XML: <zipCode>01234</zipCode>
// This tool outputs: { "zipCode": "01234" }  ← correct
// But if a downstream schema coerces:
// { zipCode: z.number() }  → 1234  ← leading zero lost

// Declare ZIP codes and other padded identifiers as strings
// { zipCode: z.string() }  → "01234"  ← correct

Typowe zastosowania

Konsumowanie SOAP i starszych API XML

Starsze serwisy korporacyjne (bankowe, ubezpieczeniowe, logistyczne) często udostępniają API SOAP zwracające XML. Przekonwertuj odpowiedź na JSON, aby pracować z danymi przy użyciu nowoczesnych narzędzi JavaScript, przechowywać je w bazie dokumentów lub przekazywać do konsumenta REST API.

Przetwarzanie kanałów RSS i Atom

Kanały RSS 2.0 i Atom 1.0 to XML. Przekonwertuj XML kanału na JSON, aby wyodrębniać tytuły, linki, daty publikacji i opisy dla agregatorów kanałów, potoków treści i systemów powiadomień bez zależności od biblioteki parsującej XML.

Parsowanie plików mapy strony

Pliki sitemap.xml wyliczają URL-e witryny z metadanymi. Przekonwertuj mapę strony na JSON, aby analizować pokrycie URL-ami, budować kolejki indeksowania, porównywać mapy stron w różnych środowiskach lub przekazywać URL-e do narzędzia sprawdzającego linki lub audytu SEO.

Transformacja plików konfiguracyjnych

Wiele systemów korporacyjnych (Spring, Maven, Ant, JBoss, Tomcat) używa plików konfiguracyjnych XML. Przekonwertuj je na JSON do analizy, skryptów migracyjnych, generowania dokumentacji lub importowania do narzędzi natywnie obsługujących JSON.

Programowanie na Android

Zasoby Androida, pliki układów i AndroidManifest.xml to XML. Przekonwertuj je na JSON dla skryptów analitycznych, automatycznego audytu lub generowania dokumentacji o zadeklarowanych uprawnieniach, aktywnościach i wartościach zasobów.

Migracja danych i ETL

Eksporty danych z systemów korporacyjnych (ERP, CRM, płace) często są dostarczane jako XML. Przekonwertuj na JSON jako pierwszy krok w potoku ETL, aby załadować dane do magazynu natywnie obsługującego JSON, takiego jak MongoDB, Firestore lub REST API.

Szczegóły techniczne

DOMParser przeglądarki do parsowania XML

Dane wejściowe XML są parsowane przy użyciu natywnego DOMParser przeglądarki z typem MIME «text/xml» — tego samego silnika używanego do renderowania SVG i XHTML. Jest w pełni zgodny z XML 1.0 i raportuje błędy poprawności strukturalnej z informacją o numerze wiersza i kolumny. Podejście to obsługuje przestrzenie nazw, sekcje CDATA, instrukcje przetwarzania i referencje encji poprawnie, bez żadnych zależności od bibliotek zewnętrznych.

Rekurencyjna serializacja DOM na JSON

Po sparsowaniu narzędzie rekurencyjnie przechodzi drzewo DOM. Węzły elementów stają się obiektami JSON; ich atrybuty stają się kluczami z prefiksem @_; elementy zawierające tylko tekst stają się zwykłymi wartościami ciągów; elementy z zarówno atrybutami, jak i treścią tekstową zyskują klucz #text dla treści tekstowej. Elementy siostrzane o tej samej nazwie są zbierane i generowane jako tablica JSON. Węzły tekstowe zawierające tylko białe znaki między elementami są odrzucane.

Bez wymuszania typów — zachowanie ciągów

Wszystkie wartości atrybutów i treść tekstowa są zapisywane w wynikowym JSON jako ciągi znaków. Nie jest stosowane żadne parseInt, parseFloat ani parsowanie logiczne. Jest to celowy wybór projektowy, aby zapobiec cichemu uszkodzeniu danych dla wartości z wiodącym zerem, precyzyjnych dziesiętnych i ciągów wyglądających jak logiczne. Wymuszanie typów, tam gdzie jest potrzebne, powinno być stosowane jawnie w kodzie docelowym.

100% w przeglądarce — bez przesyłania, bez serwera

Całe przetwarzanie odbywa się w silniku JavaScript przeglądarki. Żadne dane nie są przesyłane przez sieć w żadnym momencie. Dane wejściowe większe niż 200 KB automatycznie przełączają się z trybu na żywo na tryb ręczny (wymagający jawnego kliknięcia Konwertuj), aby utrzymać responsywność przeglądarki i zapobiec blokowaniu głównego wątku podczas intensywnego przechodzenia przez DOM.

Dobre praktyki

Najpierw zwaliduj poprawność strukturalną XML

Jeśli źródłem XML jest ręcznie pisany tekst lub system, który czasem produkuje nieprawidłowe wyjście, zwaliduj go przed konwersją. Użyj przycisku Waliduj w Formatowaniu XML, aby potwierdzić poprawność strukturalną XML i uzyskać precyzyjne lokalizacje błędów dla problemów.

Normalizuj pola «jeden lub wiele» do tablic

Gdy schemat XML dopuszcza jeden lub wiele elementów podrzędnych o tej samej nazwie, wynik JSON będzie obiektem dla jednego elementu i tablicą dla wielu. Zawsze normalizuj te pola w kodzie konsumującym: const items = [].concat(result.items ?? []) — jest to bezpieczne dla zera, jednego lub wielu elementów i zapobiega błędom TypeError.

Stosuj wymuszanie typów jawnie i wybiórczo

Ponieważ narzędzie zachowuje wszystkie wartości jako ciągi, stosuj wymuszanie typów świadomie w kodzie dla konkretnych pól, które tego wymagają. Używanie parseInt(val, 10) dla znanych pól całkowitoliczbowych jest bezpieczne. Stosowanie wymuszania ogólnie przez Number(val) grozi uszkodzeniem wartości z wiodącym zerem, pustych ciągów i precyzyjnych dziesiętnych.

Sprawdzaj #text przy dostępie do wartości elementów

Jeśli element może mieć atrybuty w niektórych ładunkach i nie mieć ich w innych, jego wartość JSON będzie albo zwykłym ciągiem (bez atrybutów), albo obiektem z kluczami @_ i kluczem #text (z atrybutami). Pisz odporne akcesory: const val = typeof node === 'object' ? node['#text'] : node. Ten wzorzec obsługuje oba kształty i unika cichych wartości undefined.

Dla bezstratnej pracy z XML użyj Formatowania XML

Konwersja XML na JSON odrzuca komentarze, instrukcje przetwarzania i semantykę przestrzeni nazw. Jeśli chcesz zachować całą zawartość XML dokładnie, użyj Formatowania XML, aby upiększyć, zminimalizować i walidować bez żadnych strat. Konwertuj na JSON tylko wtedy, gdy musisz pracować z danymi w kontekście natywnym dla JSON.

Najczęściej zadawane pytania