XML Formatter

About XML Document Formatting

XML formatting transforms compressed or poorly structured XML documents into well-organized, human-readable format with proper indentation, line breaks, and attribute alignment. Essential for configuration files, web services, data exchange, and document processing.

Proper element indentation and nesting
Attribute formatting and alignment
CDATA and comment preservation
XML validation and error reporting
Minification and compression options

XML Formatting Features

Structure Enhancement

Hierarchical element indentation
Consistent tag spacing
Attribute value formatting
Text content wrapping
Empty element optimization

Customization Options

Indentation style (spaces or tabs)
Line ending normalization
Attribute wrapping rules
Comment formatting preferences
Namespace declaration organization

Frequently Asked Questions

Does XML formatting change document meaning?

No! XML formatting only changes whitespace and presentation. The document structure, element content, and attributes remain identical. XML parsers treat formatted and unformatted XML the same way.

How do I handle mixed content elements?

Mixed content (elements with both text and child elements) requires careful formatting. The formatter preserves text content while properly indenting child elements to maintain readability.

What about XML namespaces?

Namespaces are preserved during formatting. The formatter can organize namespace declarations for better readability while maintaining all prefix bindings and qualified names.

Should I format XML for production?

For human-readable configs and documentation, yes. For high-volume data exchange, consider minified XML to reduce bandwidth and improve performance.

XML Formatting Examples

Before Formatting (Minified):

<?xml version="1.0" encoding="UTF-8"?><root><users><user id="1"><name>John Doe</name><email>john@example.com</email><profile><age>30</age><location>New York</location></profile></user><user id="2"><name>Jane Smith</name><email>jane@example.com</email><profile><age>25</age><location>Los Angeles</location></profile></user></users></root>

Issues: No structure visible, difficult to read and edit

After Formatting (Pretty):

<?xml version="1.0" encoding="UTF-8"?>
<root>
  <users>
    <user id="1">
      <name>John Doe</name>
      <email>john@example.com</email>
      <profile>
        <age>30</age>
        <location>New York</location>
      </profile>
    </user>
    <user id="2">
      <name>Jane Smith</name>
      <email>jane@example.com</email>
      <profile>
        <age>25</age>
        <location>Los Angeles</location>
      </profile>
    </user>
  </users>
</root>

Improvements: Clear hierarchy, easy to navigate and modify

XML Formatting Styles

Configuration XML (Compact):

<configuration>
  <database host="localhost" port="5432" name="myapp" />
  <cache enabled="true" ttl="3600" />
  <logging level="info" file="/var/log/app.log" />
</configuration>

Self-closing tags, attributes on same line

Data XML (Expanded):

<products>
  <product 
    id="123" 
    category="electronics"
    available="true">
    <name>Smartphone</name>
    <description>
      Latest model with advanced features
    </description>
    <price currency="USD">599.99</price>
    <specifications>
      <memory>8GB RAM</memory>
      <storage>128GB</storage>
    </specifications>
  </product>
</products>

Attributes on separate lines, detailed content structure

Advanced XML Formatting

XML with Namespaces:

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope 
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:web="http://example.com/webservice">
  <soap:Header>
    <web:Authentication>
      <web:Username>user123</web:Username>
      <web:Token>abc123xyz</web:Token>
    </web:Authentication>
  </soap:Header>
  <soap:Body>
    <web:GetUserRequest>
      <web:UserId>12345</web:UserId>
      <web:IncludeProfile>true</web:IncludeProfile>
    </web:GetUserRequest>
  </soap:Body>
</soap:Envelope>

XML with CDATA and Comments:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Application configuration file -->
<config>
  <!-- Database settings -->
  <database>
    <connectionString>
      <![CDATA[
        Server=localhost;Database=MyApp;
        User Id=admin;Password=secret123;
      ]]>
    </connectionString>
    <timeout>30</timeout>
  </database>
  
  <!-- Custom SQL queries -->
  <queries>
    <userQuery>
      <![CDATA[
        SELECT u.id, u.name, p.title 
        FROM users u 
        LEFT JOIN posts p ON u.id = p.user_id 
        WHERE u.active = 1
      ]]>
    </userQuery>
  </queries>
</config>

XML Formatting Best Practices

Consistent Indentation: Use 2 or 4 spaces consistently throughout the document
Attribute Organization: Put multiple attributes on separate lines for readability
Empty Elements: Use self-closing tags for empty elements (<tag />)
Comment Placement: Add meaningful comments above complex sections
Namespace Declarations: Declare namespaces at the root or appropriate level
CDATA Usage: Use CDATA sections for content with special characters
Encoding Declaration: Always specify encoding in the XML declaration

Programming Integration

JavaScript XML Formatting:

function formatXML(xml, indent = '  ') {
  const parser = new DOMParser();
  const serializer = new XMLSerializer();
  
  try {
    const doc = parser.parseFromString(xml, 'application/xml');
    
    // Check for parsing errors
    const parseError = doc.querySelector('parsererror');
    if (parseError) {
      throw new Error('Invalid XML: ' + parseError.textContent);
    }
    
    // Format the XML
    const formatted = formatNode(doc.documentElement, '', indent);
    return '<?xml version="1.0" encoding="UTF-8"?>\n' + formatted;
    
  } catch (error) {
    throw new Error('XML formatting failed: ' + error.message);
  }
}

function formatNode(node, currentIndent, indent) {
  let result = '';
  
  if (node.nodeType === 1) { // Element node
    result += currentIndent + '<' + node.nodeName;
    
    // Add attributes
    for (let attr of node.attributes) {
      result += ' ' + attr.name + '="' + attr.value + '"';
    }
    
    if (node.childNodes.length === 0) {
      result += ' />\n';
    } else {
      result += '>\n';
      
      // Process child nodes
      for (let child of node.childNodes) {
        if (child.nodeType === 1) { // Element
          result += formatNode(child, currentIndent + indent, indent);
        } else if (child.nodeType === 3) { // Text
          const text = child.textContent.trim();
          if (text) {
            result += currentIndent + indent + text + '\n';
          }
        }
      }
      
      result += currentIndent + '</' + node.nodeName + '>\n';
    }
  }
  
  return result;
}

// Usage
const xmlString = '<root><item id="1">test</item></root>';
const formatted = formatXML(xmlString);
console.log(formatted);

Python XML Formatting:

import xml.etree.ElementTree as ET
from xml.dom import minidom

def format_xml(xml_string, indent='  '):
    """Format XML string with proper indentation"""
    try:
        # Parse the XML
        root = ET.fromstring(xml_string)
        
        # Convert back to string with formatting
        rough_string = ET.tostring(root, encoding='unicode')
        
        # Use minidom for pretty printing
        reparsed = minidom.parseString(rough_string)
        formatted = reparsed.toprettyxml(indent=indent)
        
        # Clean up extra whitespace
        lines = [line for line in formatted.split('\n') if line.strip()]
        return '\n'.join(lines)
        
    except ET.ParseError as e:
        raise ValueError(f"Invalid XML: {e}")

def format_xml_file(input_file, output_file, indent='  '):
    """Format XML file and save to new file"""
    with open(input_file, 'r', encoding='utf-8') as f:
        xml_content = f.read()
    
    formatted = format_xml(xml_content, indent)
    
    with open(output_file, 'w', encoding='utf-8') as f:
        f.write(formatted)
    
    print(f"Formatted XML saved to {output_file}")

# Usage
xml_str = '<root><item id="1"><name>test</name></item></root>'
formatted = format_xml(xml_str)
print(formatted)

Common Use Cases

Configuration file maintenance
Web service SOAP/REST responses
Data export and import formatting
XML schema and documentation
Build system configuration (Maven, Ant)
Database migration scripts
API response debugging
Template and transformation files