XML Formatter

XML फ़ॉर्मेटिंग क्या है?

XML फ़ॉर्मेटिंग (जिसे XML प्रिटी-प्रिंटिंग या XML beautification भी कहते हैं) वह प्रक्रिया है जिसमें किसी XML दस्तावेज़ में consistent इंडेंटेशन और लाइन ब्रेक जोड़े जाते हैं ताकि उसकी hierarchical structure साफ़ दिखाई दे सके। API, कॉन्फ़िगरेशन जनरेटर या serializers से मिलने वाला raw XML अक्सर टैगों के बीच कोई space नहीं होने के साथ एक ही लाइन में आता है। XML फ़ॉर्मेटर उस दस्तावेज़ को एक tree में parse करता है, फिर consistent spacing के साथ उसे फिर से serialize करता है।

XML 1.0 विनिर्देश (W3C अनुशंसा, पाँचवाँ संस्करण) एक कठोर व्याकरण परिभाषित करता है जिसमें प्रत्येक आरंभिक टैग का एक समापन टैग होना चाहिए या वह स्वयं-समाप्त होना चाहिए, विशेषताओं में उद्धरण चिह्न होने चाहिए, और पाँच वर्णों (<, >, &, ", ') के लिए entity escaping ज़रूरी है। एक फ़ॉर्मेटर को इन नियमों का पालन करते हुए केवल ऐसे रिक्त स्थान जोड़ने चाहिए जो दस्तावेज़ की सूचना-समुच्चय (infoset) को नहीं बदलते।

फ़ॉर्मेट किया गया XML कोड समीक्षा के दौरान पढ़ना आसान होता है, संस्करण नियंत्रण में अंतर निकालना सरल होता है, और जब कोई सेवा अप्रत्याशित डेटा लौटाती है तो डीबग करना सुगम होता है। फ़ॉर्मेटिंग क्रिया स्वयं में कोई हानि नहीं करती: दस्तावेज़ की तार्किक सामग्री अपरिवर्तित रहती है, केवल प्रस्तुति बदलती है। git diff और pull request review platforms केवल बदली हुई lines दिखाते हैं — consistently indented XML यह सुनिश्चित करता है कि वे differences असली changes दिखाएं, reformatting का noise नहीं।

<catalog><book id="bk101"><author>Gambardella, Matthew</author><title>XML Developer's Guide</title><genre>Computer</genre><price>44.95</price><publish_date>2000-10-01</publish_date></book><book id="bk102"><author>Ralls, Kim</author><title>Midnight Rain</title><genre>Fantasy</genre><price>5.95</price><publish_date>2000-12-16</publish_date></book></catalog>

<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer's Guide</title>
    <genre>Computer</genre>
    <price>44.95</price>
    <publish_date>2000-10-01</publish_date>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <genre>Fantasy</genre>
    <price>5.95</price>
    <publish_date>2000-12-16</publish_date>
  </book>
</catalog>

ऑनलाइन XML फ़ॉर्मेटर क्यों उपयोग करें?

XML को हाथ से फ़ॉर्मेट करना त्रुटिपूर्ण और धीमा होता है, विशेष रूप से गहरी नेस्टिंग या मिश्रित नेमस्पेस वाले दस्तावेज़ों के लिए। ब्राउज़र-आधारित फ़ॉर्मेटर फ़ाइल के आकार की परवाह किए बिना एक सेकंड से भी कम समय में फ़ॉर्मेट किया हुआ परिणाम देता है।

XML Formatter के उपयोग के मामले

XML पूर्वपरिभाषित इकाई संदर्भ

XML अपनी सिंटैक्स के लिए पाँच वर्ण आरक्षित रखता है। जब ये वर्ण सामग्री या विशेषता मानों में शाब्दिक पाठ के रूप में प्रकट होते हैं, तो उन्हें पूर्वपरिभाषित इकाई संदर्भों से प्रतिस्थापित किया जाना चाहिए। एक सही फ़ॉर्मेटर प्रिटी-प्रिंटिंग के दौरान इन इकाइयों को सुरक्षित रखता है।

XML इंडेंटेशन शैलियों की तुलना

XML इंडेंटेशन का कोई एकल मानक नहीं है। चुनाव आपकी टीम की परंपराओं और आपकी पाइपलाइन के उपकरणों पर निर्भर करता है। यहाँ तीन सबसे सामान्य शैलियाँ हैं।

कोड उदाहरण: XML को प्रोग्रामेटिक रूप से फ़ॉर्मेट करें

जब आपको किसी स्क्रिप्ट या निर्माण प्रक्रिया में XML फ़ॉर्मेट करना हो, तो प्रत्येक प्रमुख प्रोग्रामिंग भाषा में एक अंतर्निर्मित या मानक-लाइब्रेरी विकल्प उपलब्ध है। नीचे कार्यशील उदाहरण हैं जिन्हें आप सीधे प्रतिलिपि कर सकते हैं।

const raw = '<root><item>hello</item></root>'
const parser = new DOMParser()
const doc = parser.parseFromString(raw, 'application/xml')
const serializer = new XMLSerializer()
const xml = serializer.serializeToString(doc)

// Indent with XSLT (browser-native approach)
const xslt = new DOMParser().parseFromString(`
  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml" indent="yes"/>
    <xsl:template match="node()|@*">
      <xsl:copy><xsl:apply-templates select="node()|@*"/></xsl:copy>
    </xsl:template>
  </xsl:stylesheet>`, 'application/xml')

const proc = new XSLTProcessor()
proc.importStylesheet(xslt)
const formatted = proc.transformToDocument(doc)
console.log(new XMLSerializer().serializeToString(formatted))
// → <root>\n  <item>hello</item>\n</root>

import xml.dom.minidom

raw = '<root><item>hello</item><item>world</item></root>'
dom = xml.dom.minidom.parseString(raw)
print(dom.toprettyxml(indent='  '))
# → <?xml version="1.0" ?>
# → <root>
# →   <item>hello</item>
# →   <item>world</item>
# → </root>

# With lxml (handles namespaces, XSD, large files)
from lxml import etree
tree = etree.fromstring(raw.encode())
print(etree.tostring(tree, pretty_print=True).decode())

package main

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

func formatXML(raw string) (string, error) {
    decoder := xml.NewDecoder(strings.NewReader(raw))
    var out strings.Builder
    encoder := xml.NewEncoder(&out)
    encoder.Indent("", "  ")
    for {
        tok, err := decoder.Token()
        if err != nil {
            break
        }
        encoder.EncodeToken(tok)
    }
    encoder.Flush()
    return out.String(), nil
}
// formatXML("<a><b>1</b></a>") → "<a>\n  <b>1</b>\n</a>"

# Format XML file with xmllint (part of libxml2, pre-installed on macOS/Linux)
xmllint --format input.xml > formatted.xml

# Format from stdin
echo '<a><b>1</b></a>' | xmllint --format -
# → <?xml version="1.0"?>
# → <a>
# →   <b>1</b>
# → </a>

# Validate and format at the same time
xmllint --format --schema schema.xsd input.xml

अक्सर पूछे जाने वाले प्रश्न