XML vs JSON：どちらを使うべきか — 開発者向け完全比較

XML and JSON are the two most widely used data interchange formats in software development. While JSON has become the dominant choice for web APIs, XML remains essential in many enterprise and document-centric use cases. This guide provides a comprehensive comparison with side-by-side examples, a detailed feature table, performance benchmarks, and practical migration patterns.

Format and validate your XML instantly with our free XML Formatter tool →

Quick Answer: Which Should You Use?

Use JSON when building REST APIs, web applications, configuration files, or working with NoSQL databases. JSON is lighter, faster to parse, and natively supported in JavaScript.

Use XML when you need document markup, namespaces, schema validation, XSLT transformations, or working with enterprise systems (SOAP, RSS/Atom, SVG, XHTML). XML excels at representing mixed content and self-describing documents.

Syntax Comparison: Same Data, Two Formats

Here is the same data structure expressed in both XML and JSON:

XML

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book isbn="978-0-13-468599-1" category="programming">
    <title lang="en">The Pragmatic Programmer</title>
    <authors>
      <author>David Thomas</author>
      <author>Andrew Hunt</author>
    </authors>
    <year>2019</year>
    <price currency="USD">49.95</price>
    <inStock>true</inStock>
    <tags>
      <tag>programming</tag>
      <tag>best-practices</tag>
      <tag>career</tag>
    </tags>
  </book>
</bookstore>

JSON

{
  "bookstore": {
    "books": [
      {
        "isbn": "978-0-13-468599-1",
        "category": "programming",
        "title": "The Pragmatic Programmer",
        "titleLang": "en",
        "authors": [
          "David Thomas",
          "Andrew Hunt"
        ],
        "year": 2019,
        "price": 49.95,
        "priceCurrency": "USD",
        "inStock": true,
        "tags": ["programming", "best-practices", "career"]
      }
    ]
  }
}

Feature Comparison Table

When to Use JSON

// REST API response (JSON)
{
  "status": "success",
  "data": {
    "users": [
      { "id": 1, "name": "Alice", "email": "alice@example.com" },
      { "id": 2, "name": "Bob", "email": "bob@example.com" }
    ],
    "pagination": { "page": 1, "total": 42 }
  }
}

// package.json
{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "dev": "next dev",
    "build": "next build"
  },
  "dependencies": {
    "react": "^19.0.0",
    "next": "^15.0.0"
  }
}

When to Use XML

<!-- SOAP Request -->
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <GetStockPrice xmlns="http://example.com/stocks">
      <StockName>GOOG</StockName>
    </GetStockPrice>
  </soap:Body>
</soap:Envelope>

<!-- RSS Feed -->
<rss version="2.0">
  <channel>
    <title>DevToolBox Blog</title>
    <link>https://viadreams.cc/en/blog</link>
    <item>
      <title>XML vs JSON Comparison</title>
      <description>Complete guide...</description>
    </item>
  </channel>
</rss>

<!-- SVG -->
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
  <circle cx="50" cy="50" r="40" fill="#3b82f6" />
  <text x="50" y="55" text-anchor="middle" fill="white">SVG</text>
</svg>

<!-- Maven pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>my-app</artifactId>
  <version>1.0-SNAPSHOT</version>
</project>

Performance Benchmarks

Typical performance characteristics when processing the same dataset (approximate values, actual results vary by implementation and data):

Note: XML streaming parsers (SAX/StAX) can process very large files with constant memory. JSON streaming is possible but requires libraries like json-stream or ijson. For small payloads (<100KB), the difference is negligible.

Parsing in Different Languages

JavaScript / TypeScript

// --- JSON parsing (built-in) ---
const jsonStr = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonStr);
console.log(obj.name); // "Alice"

// Serialize back
const output = JSON.stringify(obj, null, 2);

// --- XML parsing (browser) ---
const xmlStr = '<user><name>Alice</name><age>30</age></user>';
const parser = new DOMParser();
const doc = parser.parseFromString(xmlStr, 'text/xml');
const name = doc.querySelector('name')?.textContent; // "Alice"

// --- XML parsing (Node.js with xml2js) ---
import { parseStringPromise } from 'xml2js';
const result = await parseStringPromise(xmlStr);
console.log(result.user.name[0]); // "Alice"

Python

import json
import xml.etree.ElementTree as ET

# --- JSON ---
json_str = '{"name": "Alice", "age": 30}'
data = json.loads(json_str)
print(data["name"])  # Alice

# Serialize
output = json.dumps(data, indent=2)

# --- XML ---
xml_str = '<user><name>Alice</name><age>30</age></user>'
root = ET.fromstring(xml_str)
print(root.find('name').text)  # Alice

# --- XML with xmltodict (pip install xmltodict) ---
import xmltodict
doc = xmltodict.parse(xml_str)
print(doc['user']['name'])  # Alice

Java

// --- JSON with Jackson ---
import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();
Map<String, Object> data = mapper.readValue(
    "{\"name\":\"Alice\",\"age\":30}",
    Map.class
);
System.out.println(data.get("name")); // Alice

// --- XML with Jackson XML ---
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

XmlMapper xmlMapper = new XmlMapper();
Map<String, Object> xmlData = xmlMapper.readValue(
    "<user><name>Alice</name><age>30</age></user>",
    Map.class
);

// --- XML with DOM ---
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
Document doc = factory.newDocumentBuilder().parse(
    new InputSource(new StringReader(xmlStr))
);
String name = doc.getElementsByTagName("name")
    .item(0).getTextContent(); // Alice

Go

package main

import (
    "encoding/json"
    "encoding/xml"
    "fmt"
)

// --- JSON ---
type User struct {
    Name string `json:"name" xml:"name"`
    Age  int    `json:"age"  xml:"age"`
}

func main() {
    // JSON
    jsonStr := []byte(`{"name":"Alice","age":30}`)
    var user User
    json.Unmarshal(jsonStr, &user)
    fmt.Println(user.Name) // Alice

    // XML
    xmlStr := []byte(`<user><name>Alice</name><age>30</age></user>`)
    var xmlUser User
    xml.Unmarshal(xmlStr, &xmlUser)
    fmt.Println(xmlUser.Name) // Alice
}

Migration: XML to JSON Conversion Patterns

Converting XML to JSON is not always straightforward because of fundamental differences. Here are the common patterns and gotchas:

Simple Elements

<!-- XML -->
<user>
  <name>Alice</name>
  <age>30</age>
  <active>true</active>
</user>

// JSON (straightforward mapping)
{
  "name": "Alice",
  "age": 30,
  "active": true
}

Attributes

<!-- XML with attributes -->
<product id="123" category="electronics">
  <name>Laptop</name>
  <price currency="USD">999.99</price>
</product>

// JSON — Convention 1: prefix with @
{
  "@id": "123",
  "@category": "electronics",
  "name": "Laptop",
  "price": {
    "@currency": "USD",
    "#text": 999.99
  }
}

// JSON — Convention 2: flatten
{
  "id": "123",
  "category": "electronics",
  "name": "Laptop",
  "price": 999.99,
  "priceCurrency": "USD"
}

Mixed Content

<!-- XML mixed content (text + elements interleaved) -->
<p>This is <b>bold</b> and <i>italic</i> text.</p>

// JSON — No clean way to represent this!
// Option 1: HTML string
{ "p": "This is <b>bold</b> and <i>italic</i> text." }

// Option 2: Array of segments (verbose)
{
  "p": [
    { "type": "text", "value": "This is " },
    { "type": "b", "value": "bold" },
    { "type": "text", "value": " and " },
    { "type": "i", "value": "italic" },
    { "type": "text", "value": " text." }
  ]
}

Repeated Elements

<!-- XML repeated elements -->
<users>
  <user>Alice</user>
  <user>Bob</user>
  <user>Charlie</user>
</users>

// JSON — Always use arrays for repeated elements
{
  "users": ["Alice", "Bob", "Charlie"]
}

// Watch out: single-element case in XML
<users>
  <user>Alice</user>
</users>
// Some converters output a string instead of array!
// BAD:  { "users": { "user": "Alice" } }
// GOOD: { "users": { "user": ["Alice"] } }
// Always force arrays for elements that can repeat.

Important: There is no single "correct" way to convert XML to JSON. Different converters use different conventions (e.g., @attr vs _attr vs $attr for attributes). Always document your conversion convention and be consistent.

Alternatives to XML and JSON

While XML and JSON dominate, several other formats address specific needs:

Format and validate your XML instantly with our free XML Formatter tool →

Format and validate JSON with our free JSON Formatter tool →