XML vs JSON：何时使用哪个 — 开发者完整对比

XML 和 JSON 是软件开发中使用最广泛的两种数据交换格式。虽然 JSON 已成为 Web API 的主流选择，但 XML 在许多企业级和文档导向的场景中仍然不可或缺。本指南提供全面的对比分析，包含并排示例、详细功能对比表、性能基准测试和实用的迁移模式。

使用我们的免费 XML 格式化工具即时格式化和验证 XML →

快速解答：应该使用哪个？

使用 JSON：构建 REST API、Web 应用、配置文件，或使用 NoSQL 数据库时。JSON 更轻量、解析更快，且在 JavaScript 中原生支持。

使用 XML：需要文档标记、命名空间、模式验证、XSLT 转换，或与企业系统（SOAP、RSS/Atom、SVG、XHTML）交互时。XML 擅长表示混合内容和自描述文档。

语法对比：相同数据，两种格式

以下是用 XML 和 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"]
      }
    ]
  }
}

功能对比表

何时使用 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"
  }
}

何时使用 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>

性能基准测试

处理相同数据集的典型性能特征（近似值，实际结果因实现和数据而异）：

注意：XML 流式解析器（SAX/StAX）可以用恒定内存处理超大文件。JSON 流式解析也可行，但需要 json-stream 或 ijson 等库。对于小于 100KB 的载荷，差异可以忽略不计。

不同语言中的解析方式

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
}

迁移：XML 到 JSON 转换模式

由于两者的根本差异，将 XML 转换为 JSON 并不总是简单直接的。以下是常见的模式和注意事项：

简单元素

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

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

属性

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

混合内容

<!-- 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." }
  ]
}

重复元素

<!-- 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.

重要提示：XML 转 JSON 没有唯一"正确"的方式。不同的转换器使用不同的约定（如属性的表示：@attr、_attr 或 $attr）。务必记录你的转换约定并保持一致。

XML 和 JSON 的替代方案

虽然 XML 和 JSON 占据主导地位，但还有一些格式可以满足特定需求：

使用我们的免费 XML 格式化工具即时格式化和验证 XML →

使用我们的免费 JSON 格式化工具格式化和验证 JSON →