Konwerter JSON na XML

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

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

Kluczowe funkcje

Przykłady

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

Jak używać

1. 1

   Wklej dane JSON

   Wprowadź lub wklej dane JSON do pola wejściowego powyżej. Możesz też kliknąć «Wczytaj przykład», aby wypróbować próbkę — obiekt odpowiedzi API, ładunek tablicowy lub obiekt używający atrybutów @_ i #text.

2. 2

   Zobacz wynik XML na żywo

   XML pojawia się natychmiast w panelu wyjściowym. Obiekty z jednym kluczem używają swojego klucza jako elementu głównego; obiekty z wieloma kluczami owijają w <root>; klucze z prefiksem @_ stają się atrybutami; tablice stają się powtarzającymi się elementami podrzędnymi. Dostosuj wcięcie (2 lub 4 spacje) według potrzeb.

3. 3

   Kopiuj lub pobierz

   Kliknij Kopiuj, aby przenieść XML do schowka, lub Pobierz, aby zapisać jako plik .xml. Aby walidować lub ponownie sformatować wynik, wklej go do Formatowania XML.

Typowe problemy przy konwersji

// 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'

Typowe zastosowania

Wywoływanie SOAP i starszych usług webowych XML

Zbuduj ładunek JSON w aplikacji, przekonwertuj go na XML i wyślij POST na punkt końcowy SOAP. Pozwala to uniknąć ręcznego budowania ciągów XML i umożliwia pracę z danymi w natywnej strukturze JSON aż do momentu, gdy trzeba je serializować dla starszego serwisu.

Generowanie plików konfiguracyjnych XML

Spring, Maven, Ant, Tomcat i Android — wszystkie używają formatów konfiguracyjnych XML. Generuj lub transformuj dane konfiguracyjne jako JSON — łatwiejsze do porównywania i wersjonowania — a następnie konwertuj na XML do wdrożenia.

Tworzenie XML mapy strony i kanału RSS

Systemy zarządzania treścią i generatory stron statycznych często przechowują metadane stron jako JSON. Przekonwertuj te metadane na XML sitemap.xml lub kanał RSS do zgłaszania do wyszukiwarek lub syndykowania treści dla czytników kanałów.

Integracja danych korporacyjnych (EDI / ERP / CRM)

Systemy ERP (SAP, Oracle), platformy CRM i sieci EDI często wymieniają dane w XML. Przekonwertuj eksporty JSON z nowoczesnych REST API na XML, aby zasilać te systemy bez budowania niestandardowego serializatora XML.

Pliki zasobów Androida

Zasoby ciągów Androida, ograniczenia układów i wpisy manifestu to XML. Generuj lub aktualizuj pliki zasobów programatycznie ze źródeł danych JSON i konwertuj do wymaganego formatu XML dla systemu kompilacji Androida.

Generowanie SVG i grafiki wektorowej

SVG to XML. Buduj strukturę SVG jako dane JSON — ścieżki, kształty, kolory, transformacje — a następnie konwertuj na XML, aby tworzyć poprawne pliki SVG dla web, druku lub narzędzi do edycji wektorowej.

Szczegóły techniczne

Parsowanie JSON zgodne z RFC 8259

Dane wejściowe JSON są parsowane przy użyciu natywnego JSON.parse() przeglądarki, który jest w pełni zgodny z RFC 8259. Zapewnia to dokładne komunikaty błędów składni z informacją o pozycji (numer wiersza i kolumny, najlepsze przybliżenie) i obsługuje wszystkie typy danych JSON: ciągi znaków, liczby, wartości logiczne, null, tablice i obiekty.

Niestandardowy rekurencyjny serializator JSON na XML

Po sparsowaniu niestandardowy rekurencyjny serializator przechodzi drzewo JSON. Klucze obiektów zaczynające się od @_ są emitowane jako atrybuty XML na elemencie nadrzędnym. Klucz #text jest emitowany jako treść tekstowa elementu. Zwykłe klucze obiektów stają się elementami podrzędnymi. Wartości tablic produkują powtarzające się elementy siostrzane o tej samej nazwie. Znaki specjalne (<, >, &, ", ') w treści tekstowej i wartościach atrybutów są escapowane do ich referencji encji XML.

Normalizacja elementu głównego

Ponieważ XML wymaga dokładnie jednego elementu głównego, serializator stosuje normalizację elementu głównego przed budowaniem dokumentu: obiekty z jednym kluczem używają klucza jako elementu głównego; obiekty z wieloma kluczami i tablice najwyższego poziomu otrzymują syntetyczny kontener <root>. Gwarantuje to, że wyjście jest zawsze poprawnym strukturalnie XML, niezależnie od kształtu wejścia.

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 podczas intensywnej serializacji.

Dobre praktyki

Kontroluj element główny przez obiekt z jednym kluczem

Najczystszym sposobem na uzyskanie znaczącego XML jest upewnienie się, że JSON najwyższego poziomu jest obiektem z jednym kluczem, którego nazwa jest pożądaną nazwą elementu głównego. Owijanie danych z wieloma kluczami pod jedną nazwaną nazwą daje semantycznie znaczący element główny zamiast ogólnego kontenera <root>.

Używaj @_ i #text dla XML z wieloma atrybutami

Jeśli docelowy schemat XML używa wielu atrybutów (powszechne w plikach konfiguracyjnych, SVG i kopertach SOAP), przekształć JSON do używania kluczy z prefiksem @_ i #text przed konwersją. Wynikowy XML będzie dokładnie pasować do docelowego schematu bez dalszego przetwarzania.

Owijaj tablice w nazwane obiekty dla znaczących nazw znaczników

Tablica najwyższego poziomu produkuje ogólny wzorzec <root><item>...</item></root>, gdzie <item> to stała dosłowna nazwa. Owijanie tablicy pod nazwanym kluczem — { "products": [...] } — produkuje powtarzające się elementy <products> (nazwa klucza jest reużywana dla każdego elementu tablicy) pod kontenerem <root>. Daje to domenowo znaczącą nazwę znacznika i jest prawie zawsze lepsze dla XML, który będzie parsowany lub walidowany przez schemat.

Waliduj wynik za pomocą Formatowania XML

Po konwersji wklej wynikowy XML do Formatowania XML, aby walidować poprawność strukturalną, sprawdzić wcięcia i zidentyfikować problemy strukturalne przed wysłaniem XML do dalszego serwisu lub zatwierdzeniem w systemie kontroli wersji.

Oczyść klucze JSON przed konwersją

Nazwy elementów XML muszą zaczynać się od litery lub podkreślenia i nie mogą zawierać spacji ani większości znaków specjalnych. Jeśli klucze JSON pochodzą z zewnętrznego źródła (nazwa kolumny bazy danych, nazwa pola API lub dane wejściowe użytkownika), sprawdź ich poprawność jako nazw XML przed konwersją, aby uniknąć nieprawidłowego wyjścia.

Najczęściej zadawane pytania