XML Tools Complete Guide: Formatting, Validation, and Conversion

<!-- Before formatting (minified) -->
<?xml version="1.0"?><bookstore><book category="web"><title lang="en">Learning XML</title><author>Erik T. Ray</author><year>2003</year><price>39.95</price></book></bookstore>

<!-- After formatting (beautified) -->
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="web">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <year>2003</year>
    <price>39.95</price>
  </book>
</bookstore>

<!-- Complex XML with multiple attributes -->
<configuration
  xmlns="http://example.com/config"
  version="1.0"
  environment="production">
  <database
    host="localhost"
    port="5432"
    name="mydb"
    ssl="true">
    <connection-pool
      min-size="5"
      max-size="20"
      timeout="30" />
  </database>
  <logging
    level="INFO"
    format="JSON">
    <appender type="file" path="/var/log/app.log" />
    <appender type="console" />
  </logging>
</configuration>

// Format XML with custom indentation
function formatXML(xml, indent = 2) {
  const PADDING = ' '.repeat(indent);
  const formatted = [];
  let indentLevel = 0;

  // Split by tags
  xml.split(/(<[^>]+>)/).forEach(node => {
    if (!node.trim()) return;

    if (node.match(/^<\/\w/)) {
      // Closing tag
      indentLevel--;
      formatted.push(PADDING.repeat(indentLevel) + node);
    } else if (node.match(/^<\w[^>]*[^\/]>$/)) {
      // Opening tag
      formatted.push(PADDING.repeat(indentLevel) + node);
      indentLevel++;
    } else if (node.match(/^<\w[^>]*\/>/)) {
      // Self-closing tag
      formatted.push(PADDING.repeat(indentLevel) + node);
    } else {
      // Text content
      formatted.push(PADDING.repeat(indentLevel) + node.trim());
    }
  });

  return formatted.join('\n');
}

// Using DOMParser (browser)
function formatXMLBrowser(xmlString) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
  const serializer = new XMLSerializer();
  return serializer.serializeToString(xmlDoc);
}

// Using xml-formatter library
const format = require('xml-formatter');
const formatted = format(xmlString, {
  indentation: '  ',
  collapseContent: true,
  lineSeparator: '\n'
});

// Simple well-formedness check
function isWellFormedXML(xmlString) {
  try {
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlString, 'text/xml');

    // Check for parsing errors
    const parserError = xmlDoc.querySelector('parsererror');
    if (parserError) {
      return {
        valid: false,
        error: parserError.textContent
      };
    }

    return { valid: true };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

// Common validation errors
const invalidXML = `
<person>
  <name>John</name>
  <age>30
  <!-- Missing closing tag -->
</person>
`;

const result = isWellFormedXML(invalidXML);
console.log(result); // { valid: false, error: '...' }

// XML Schema (XSD) definition
const schema = `
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="person">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="name" type="xs:string"/>
        <xs:element name="age" type="xs:integer"/>
        <xs:element name="email" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
`;

// Validate XML against schema (using libxmljs)
const libxmljs = require('libxmljs');

function validateAgainstSchema(xmlString, xsdString) {
  try {
    const xmlDoc = libxmljs.parseXml(xmlString);
    const xsdDoc = libxmljs.parseXml(xsdString);

    const isValid = xmlDoc.validate(xsdDoc);

    if (!isValid) {
      return {
        valid: false,
        errors: xmlDoc.validationErrors
      };
    }

    return { valid: true };
  } catch (error) {
    return {
      valid: false,
      errors: [error.message]
    };
  }
}

// Example usage
const xml = `
<?xml version="1.0"?>
<person>
  <name>John Doe</name>
  <age>30</age>
  <email>[email protected]</email>
</person>
`;

const result = validateAgainstSchema(xml, schema);
console.log(result);

<!-- Before minification (200 bytes) -->
<?xml version="1.0" encoding="UTF-8"?>
<person>
  <name>John Doe</name>
  <age>30</age>
  <email>[email protected]</email>
</person>

<!-- After minification (98 bytes - 51% reduction) -->
<?xml version="1.0"?><person><name>John Doe</name><age>30</age><email>[email protected]</email></person>

// Minify XML (remove whitespace)
function minifyXML(xml) {
  return xml
    .replace(/\s+</g, '<')        // Remove whitespace before tags
    .replace(/>\s+/g, '>')        // Remove whitespace after tags
    .replace(/\s+\/>/g, '/>')    // Remove whitespace before self-closing
    .replace(/<!--[\s\S]*?-->/g, '') // Remove comments
    .trim();
}

// Advanced minification preserving significant whitespace
function minifyXMLPreserveContent(xml) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xml, 'text/xml');

  function minifyNode(node) {
    if (node.nodeType === Node.TEXT_NODE) {
      // Preserve text content
      return node.textContent;
    }

    if (node.nodeType === Node.ELEMENT_NODE) {
      let result = `<${node.nodeName}`;

      // Add attributes
      Array.from(node.attributes).forEach(attr => {
        result += ` ${attr.name}="${attr.value}"`;
      });

      if (node.childNodes.length === 0) {
        result += '/>';
      } else {
        result += '>';
        Array.from(node.childNodes).forEach(child => {
          result += minifyNode(child);
        });
        result += `</${node.nodeName}>`;
      }

      return result;
    }

    return '';
  }

  return minifyNode(xmlDoc.documentElement);
}

// Usage
const formatted = `
<?xml version="1.0"?>
<data>
  <item>Value</item>
</data>
`;

const minified = minifyXML(formatted);
console.log(minified);

// Convert XML to JSON
const xml2js = require('xml2js');

const xml = `
<?xml version="1.0"?>
<bookstore>
  <book category="web">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <price>39.95</price>
  </book>
  <book category="programming">
    <title lang="en">JavaScript Basics</title>
    <author>John Doe</author>
    <price>29.95</price>
  </book>
</bookstore>
`;

// Parse XML to JSON
xml2js.parseString(xml, {
  explicitArray: false,
  mergeAttrs: true
}, (err, result) => {
  if (err) {
    console.error('Parse error:', err);
    return;
  }

  console.log(JSON.stringify(result, null, 2));
});

/* Output:
{
  "bookstore": {
    "book": [
      {
        "category": "web",
        "title": {
          "lang": "en",
          "_": "Learning XML"
        },
        "author": "Erik T. Ray",
        "price": "39.95"
      },
      {
        "category": "programming",
        "title": {
          "lang": "en",
          "_": "JavaScript Basics"
        },
        "author": "John Doe",
        "price": "29.95"
      }
    ]
  }
}
*/

// Convert JSON to XML
const js2xmlparser = require('js2xmlparser');

const jsonData = {
  book: [
    {
      '@': { category: 'web' },
      title: {
        '@': { lang: 'en' },
        '#': 'Learning XML'
      },
      author: 'Erik T. Ray',
      price: 39.95
    },
    {
      '@': { category: 'programming' },
      title: {
        '@': { lang: 'en' },
        '#': 'JavaScript Basics'
      },
      author: 'John Doe',
      price: 29.95
    }
  ]
};

const xml = js2xmlparser.parse('bookstore', jsonData, {
  declaration: {
    encoding: 'UTF-8'
  },
  format: {
    doubleQuotes: true,
    indent: '  '
  }
});

console.log(xml);

/* Output:
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
  <book category="web">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <price>39.95</price>
  </book>
  <book category="programming">
    <title lang="en">JavaScript Basics</title>
    <author>John Doe</author>
    <price>29.95</price>
  </book>
</bookstore>
*/

// Convert XML to CSV
function xmlToCSV(xml) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xml, 'text/xml');

  // Get all book elements
  const books = xmlDoc.querySelectorAll('book');
  const rows = [];

  // Create header
  rows.push(['Category', 'Title', 'Author', 'Price'].join(','));

  // Extract data
  books.forEach(book => {
    const row = [
      book.getAttribute('category'),
      book.querySelector('title').textContent,
      book.querySelector('author').textContent,
      book.querySelector('price').textContent
    ];
    rows.push(row.join(','));
  });

  return rows.join('\n');
}

// Usage
const xml = `
<?xml version="1.0"?>
<bookstore>
  <book category="web">
    <title>Learning XML</title>
    <author>Erik T. Ray</author>
    <price>39.95</price>
  </book>
  <book category="programming">
    <title>JavaScript Basics</title>
    <author>John Doe</author>
    <price>29.95</price>
  </book>
</bookstore>
`;

const csv = xmlToCSV(xml);
console.log(csv);

/* Output:
Category,Title,Author,Price
web,Learning XML,Erik T. Ray,39.95
programming,JavaScript Basics,John Doe,29.95
*/

// Create interactive XML tree viewer
function createXMLViewer(xml, container) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xml, 'text/xml');

  function createNode(element, depth = 0) {
    const div = document.createElement('div');
    div.className = 'xml-node';
    div.style.marginLeft = `${depth * 20}px`;

    // Element name
    const elementSpan = document.createElement('span');
    elementSpan.className = 'xml-element';
    elementSpan.textContent = `<${element.nodeName}`;

    // Attributes
    if (element.attributes.length > 0) {
      Array.from(element.attributes).forEach(attr => {
        const attrSpan = document.createElement('span');
        attrSpan.className = 'xml-attribute';
        attrSpan.textContent = ` ${attr.name}="${attr.value}"`;
        elementSpan.appendChild(attrSpan);
      });
    }

    elementSpan.textContent += '>';
    div.appendChild(elementSpan);

    // Children
    const hasChildren = element.childNodes.length > 0;
    if (hasChildren) {
      Array.from(element.childNodes).forEach(child => {
        if (child.nodeType === Node.ELEMENT_NODE) {
          div.appendChild(createNode(child, depth + 1));
        } else if (child.nodeType === Node.TEXT_NODE && child.textContent.trim()) {
          const textSpan = document.createElement('span');
          textSpan.className = 'xml-text';
          textSpan.textContent = child.textContent.trim();
          div.appendChild(textSpan);
        }
      });

      // Closing tag
      const closeSpan = document.createElement('span');
      closeSpan.className = 'xml-element';
      closeSpan.textContent = `</${element.nodeName}>`;
      closeSpan.style.marginLeft = `${depth * 20}px`;
      div.appendChild(closeSpan);
    }

    return div;
  }

  container.innerHTML = '';
  container.appendChild(createNode(xmlDoc.documentElement));
}

// DOM parsing (loads entire document)
function parseXMLDOM(xmlString) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlString, 'text/xml');

  // Navigate the DOM
  const books = xmlDoc.getElementsByTagName('book');

  Array.from(books).forEach(book => {
    const title = book.getElementsByTagName('title')[0].textContent;
    const author = book.getElementsByTagName('author')[0].textContent;
    const price = book.getElementsByTagName('price')[0].textContent;

    console.log(`${title} by ${author} - $${price}`);
  });

  // Using querySelector
  const firstBook = xmlDoc.querySelector('book');
  const category = firstBook.getAttribute('category');

  // XPath queries
  const xpath = require('xpath');
  const titles = xpath.select('//title/text()', xmlDoc);
  titles.forEach(title => console.log(title.nodeValue));
}

// Node.js DOM parsing
const { DOMParser } = require('xmldom');
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, 'text/xml');

// SAX parsing (event-based, memory efficient)
const sax = require('sax');

function parseXMLSAX(xmlString) {
  const parser = sax.createStream(true);
  let currentElement = null;
  const books = [];
  let currentBook = {};

  parser.on('opentag', (node) => {
    currentElement = node.name;

    if (node.name === 'book') {
      currentBook = {
        category: node.attributes.category
      };
    }
  });

  parser.on('text', (text) => {
    if (currentElement && text.trim()) {
      currentBook[currentElement] = text.trim();
    }
  });

  parser.on('closetag', (name) => {
    if (name === 'book') {
      books.push({ ...currentBook });
      currentBook = {};
    }
    currentElement = null;
  });

  parser.on('end', () => {
    console.log('Parsed books:', books);
  });

  parser.write(xmlString);
  parser.end();
}

// Usage (great for large files)
const fs = require('fs');
const stream = fs.createReadStream('large-file.xml');
stream.pipe(parser);

// XPath queries for XML navigation
const xpath = require('xpath');
const dom = require('xmldom').DOMParser;

const xml = `
<?xml version="1.0"?>
<bookstore>
  <book category="web">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <year>2003</year>
    <price>39.95</price>
  </book>
  <book category="programming">
    <title lang="en">JavaScript Basics</title>
    <author>John Doe</author>
    <year>2020</year>
    <price>29.95</price>
  </book>
</bookstore>
`;

const doc = new dom().parseFromString(xml);

// Select all titles
const titles = xpath.select('//title/text()', doc);
console.log('Titles:', titles.map(t => t.nodeValue));

// Select books with price > 30
const expensiveBooks = xpath.select('//book[price > 30]', doc);

// Select first book's title
const firstTitle = xpath.select1('//book[1]/title/text()', doc);
console.log('First title:', firstTitle.nodeValue);

// Select all lang attributes
const languages = xpath.select('//title/@lang', doc);
console.log('Languages:', languages.map(l => l.value));

// Complex query
const webBooks = xpath.select('//book[@category="web"]/title/text()', doc);
console.log('Web books:', webBooks.map(b => b.nodeValue));

<!-- XSLT Stylesheet -->
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <html>
      <body>
        <h2>Book Catalog</h2>
        <table border="1">
          <tr>
            <th>Title</th>
            <th>Author</th>
            <th>Price</th>
          </tr>
          <xsl:for-each select="bookstore/book">
            <tr>
              <td><xsl:value-of select="title"/></td>
              <td><xsl:value-of select="author"/></td>
              <td><xsl:value-of select="price"/></td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>

<!-- JavaScript XSLT transformation -->
<script>
const xsltProcessor = new XSLTProcessor();
const xslDoc = parser.parseFromString(xslString, 'text/xml');
xsltProcessor.importStylesheet(xslDoc);

const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
const resultDoc = xsltProcessor.transformToDocument(xmlDoc);

// Get HTML output
const serializer = new XMLSerializer();
const htmlOutput = serializer.serializeToString(resultDoc);
</script>

<!-- XML with namespaces -->
<?xml version="1.0"?>
<root xmlns:h="http://www.w3.org/1999/xhtml"
      xmlns:f="http://www.example.com/furniture">

  <!-- HTML namespace -->
  <h:table>
    <h:tr>
      <h:td>Apples</h:td>
      <h:td>Bananas</h:td>
    </h:tr>
  </h:table>

  <!-- Furniture namespace -->
  <f:table>
    <f:name>Coffee Table</f:name>
    <f:width>80</f:width>
    <f:length>120</f:length>
  </f:table>

</root>

<!-- Default namespace -->
<bookstore xmlns="http://www.example.com/books">
  <book>
    <title>XML Primer</title>
  </book>
</bookstore>

// Working with namespaces in JavaScript
const xml = `
<?xml version="1.0"?>
<root xmlns:custom="http://example.com/custom">
  <custom:data>
    <custom:item>Value</custom:item>
  </custom:data>
</root>
`;

const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xml, 'text/xml');

// Query with namespace
const nsResolver = xmlDoc.createNSResolver(xmlDoc.documentElement);
const items = xmlDoc.evaluate(
  '//custom:item',
  xmlDoc,
  nsResolver,
  XPathResult.ANY_TYPE,
  null
);

// Or specify namespace explicitly
const xpath = require('xpath');
const select = xpath.useNamespaces({
  custom: 'http://example.com/custom'
});

const results = select('//custom:item/text()', xmlDoc);
console.log(results.map(r => r.nodeValue));

// XML performance optimization tips

// 1. Use SAX for large files
const sax = require('sax');
const parser = sax.createStream(true);
fs.createReadStream('large.xml').pipe(parser);

// 2. Stream processing
const { Transform } = require('stream');
const xmlStream = require('xml-stream');

const stream = fs.createReadStream('data.xml');
const xml = new xmlStream(stream);

xml.on('endElement: book', (item) => {
  // Process one item at a time
  processBook(item);
});

// 3. Lazy evaluation
function* parseXMLLazy(xml) {
  const parser = sax.parser(true);
  let current = null;

  parser.onopentag = (node) => {
    if (node.name === 'book') {
      current = { ...node.attributes };
    }
  };

  parser.onclosetag = (name) => {
    if (name === 'book' && current) {
      yield current;
      current = null;
    }
  };

  parser.write(xml).close();
}

// 4. Caching parsed results
const cache = new Map();

function parseXMLCached(xml) {
  const hash = createHash(xml);
  if (cache.has(hash)) {
    return cache.get(hash);
  }

  const result = parseXML(xml);
  cache.set(hash, result);
  return result;
}

// Robust XML error handling
function safeParseXML(xmlString) {
  try {
    const parser = new DOMParser();
    const xmlDoc = parser.parseFromString(xmlString, 'text/xml');

    // Check for parse errors
    const parseError = xmlDoc.querySelector('parsererror');
    if (parseError) {
      throw new Error(`XML Parse Error: ${parseError.textContent}`);
    }

    // Validate structure
    if (!xmlDoc.documentElement) {
      throw new Error('No document element found');
    }

    return {
      success: true,
      document: xmlDoc
    };

  } catch (error) {
    return {
      success: false,
      error: error.message,
      line: extractLineNumber(error.message)
    };
  }
}

// Validation with detailed errors
function validateXML(xmlString) {
  const errors = [];

  // Check for common issues
  if (!xmlString.trim().startsWith('<?xml')) {
    errors.push('Missing XML declaration');
  }

  // Check matching tags
  const openTags = xmlString.match(/<([a-zA-Z][a-zA-Z0-9]*)(?:\s|>)/g);
  const closeTags = xmlString.match(/<\/([a-zA-Z][a-zA-Z0-9]*)>/g);

  if (openTags && closeTags && openTags.length !== closeTags.length) {
    errors.push('Mismatched opening and closing tags');
  }

  // Try parsing
  const parseResult = safeParseXML(xmlString);
  if (!parseResult.success) {
    errors.push(parseResult.error);
  }

  return {
    valid: errors.length === 0,
    errors
  };
}

<!-- Special characters that must be escaped in XML -->

<!-- Character entities -->
<message>5 &lt; 10 &amp;&amp; 10 &gt; 5</message>
<!-- Displays: 5 < 10 && 10 > 5 -->

<quote>He said &quot;Hello&quot; to &apos;everyone&apos;</quote>
<!-- Displays: He said "Hello" to 'everyone' -->

<!-- CDATA section (no escaping needed) -->
<script>
<![CDATA[
  if (x < 10 && y > 5) {
    console.log("Success");
  }
]]>
</script>

<!-- JavaScript escaping -->
<script>
function escapeXML(str) {
  return str
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&apos;');
}

function unescapeXML(str) {
  return str
    .replace(/&quot;/g, '"')
    .replace(/&apos;/g, "'")
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&amp;/g, '&');
}
</script>

Feature              | XML                  | JSON
---------------------|----------------------|---------------------
Readability          | Verbose              | Concise
Data types           | Text (typed via XSD) | Native types
Comments             | Supported            | Not supported
Attributes           | Supported            | Not supported
Namespaces           | Supported            | Not supported
Schema validation    | XSD, DTD, RelaxNG    | JSON Schema
Transformation       | XSLT                 | JavaScript
Querying             | XPath, XQuery        | JSONPath, jq
Size                 | Larger (~30% more)   | Smaller
Parsing speed        | Slower               | Faster
Browser support      | Excellent            | Excellent
Human editing        | More difficult       | Easier
Mixed content        | Supported            | Not supported
Metadata             | Attributes           | Nested objects

Use cases:
XML: Enterprise, SOAP, Documents, Legacy systems
JSON: REST APIs, Web apps, Configuration, Modern systems