XML Minifier

XML मिनिफिकेशन क्या है?

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

XML 1.0 विनिर्देश (W3C अनुशंसा, पाँचवाँ संस्करण) की धारा 2.10 में रिक्त स्थान प्रबंधन के नियम परिभाषित हैं। टैगों के बीच का वह रिक्त स्थान जिसका कोई अर्थगत महत्त्व नहीं होता, "महत्त्वहीन रिक्त स्थान" कहलाता है। XML processors को इसे हटाने की अनुमति है। किंतु पाठ सामग्री के भीतर का रिक्त स्थान डिफ़ॉल्ट रूप से महत्त्वपूर्ण होता है — जब तक कि मूल एलिमेंट xml:space="default" घोषित न करे। एक सही XML मिनिफायर इन दोनों स्थितियों में अंतर करता है और केवल वही हटाता है जो सुरक्षित रूप से हटाया जा सकता है।

मिनिफिकेशन और संपीड़न (compression) एक-दूसरे से भिन्न हैं। Gzip या Brotli ट्रांसपोर्ट परत पर आकार कम करते हैं और पार्सिंग से पहले डीकंप्रेशन की आवश्यकता होती है। मिनिफिकेशन कच्चे दस्तावेज़ का आकार स्वयं घटाता है, इसलिए XML बिना किसी डीकंप्रेशन चरण के किसी भी पार्सर द्वारा पढ़ा जा सकता है। व्यवहार में, संपीड़न से पहले मिनिफिकेशन करने से सर्वोत्तम परिणाम मिलते हैं: पहले अनावश्यक वर्ण हटाएं, फिर संपीड़न एल्गोरिदम अधिक कुशल इनपुट पर कार्य करता है।

<?xml version="1.0" encoding="UTF-8"?>
<!-- Product catalog for Q1 2026 -->
<catalog>
  <product id="p101">
    <name>Widget A</name>
    <price currency="USD">29.99</price>
    <!-- Temporarily discounted -->
    <stock>142</stock>
  </product>
  <product id="p102">
    <name>Widget B</name>
    <price currency="EUR">19.50</price>
    <stock>87</stock>
  </product>
</catalog>

<?xml version="1.0" encoding="UTF-8"?><catalog><product id="p101"><name>Widget A</name><price currency="USD">29.99</price><stock>142</stock></product><product id="p102"><name>Widget B</name><price currency="EUR">19.50</price><stock>87</stock></product></catalog>

XML Minifier का उपयोग क्यों करें?

इंडेंटेशन और टिप्पणियों सहित फ़ॉर्मेट किया गया XML विकास और कोड समीक्षा के लिए आदर्श है। storage, transmission और machine processing के लिए वह अतिरिक्त फ़ॉर्मेटिंग बिना किसी लाभ के बाइट जोड़ती है। एक XML मिनिफायर इस अंतर को पाटता है।

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

XML मिनिफिकेशन क्या हटाता है

XML दस्तावेज़ में सब कुछ सुरक्षित रूप से नहीं हटाया जा सकता। यह संदर्भ तालिका प्रत्येक प्रकार की हटाने योग्य सामग्री और यह दर्शाती है कि उसे हटाना हमेशा सुरक्षित है या आपके उपयोग के मामले पर निर्भर करता है।

मिनिफिकेशन बनाम Gzip बनाम बाइनरी फ़ॉर्मेट

मिनिफिकेशन, संपीड़न और बाइनरी एन्कोडिंग प्रत्येक आकार की समस्या की एक अलग परत को लक्षित करते हैं। मिनिफिकेशन आउटपुट को वैध, मानव-पठनीय XML के रूप में रखता है। संपीड़न (Gzip, Brotli) आगे संकुचित करता है लेकिन पार्सिंग से पहले डीकंप्रेशन चरण की आवश्यकता होती है। बाइनरी फ़ॉर्मेट सबसे आगे जाते हैं, लेकिन कनेक्शन के दोनों छोरों पर एक संगत एन्कोडर/डीकोडर की आवश्यकता होती है — मुख्यतः एम्बेडेड सिस्टम या WSDL-भारी एंटरप्राइज़ सेवाओं के लिए व्यावहारिक।

कोड उदाहरण

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

// Minify XML by parsing and re-serializing (strips formatting)
const raw = `<root>
  <item id="1">
    <!-- note -->
    <name>Test</name>
  </item>
</root>`

const parser = new DOMParser()
const doc = parser.parseFromString(raw, 'application/xml')

// Remove comment nodes
const walker = doc.createTreeWalker(doc, NodeFilter.SHOW_COMMENT)
const comments = []
while (walker.nextNode()) comments.push(walker.currentNode)
comments.forEach(c => c.parentNode.removeChild(c))

const minified = new XMLSerializer().serializeToString(doc)
// → "<root><item id=\"1\"><name>Test</name></item></root>"

from lxml import etree

xml = """<root>
  <item id="1">
    <!-- note -->
    <name>Test</name>
  </item>
</root>"""

tree = etree.fromstring(xml.encode())

# Remove comments
for comment in tree.iter(etree.Comment):
    comment.getparent().remove(comment)

# Serialize without pretty-print (minified)
result = etree.tostring(tree, xml_declaration=False).decode()
# → '<root><item id="1"><name>Test</name></item></root>'

# With xml.etree (stdlib, no lxml needed)
import xml.etree.ElementTree as ET
root = ET.fromstring(xml)
ET.indent(root, space='')  # Python 3.9+
print(ET.tostring(root, encoding='unicode'))

package main

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

func minifyXML(input string) (string, error) {
    decoder := xml.NewDecoder(strings.NewReader(input))
    var out strings.Builder
    encoder := xml.NewEncoder(&out)
    // No indentation = minified output
    for {
        tok, err := decoder.Token()
        if err != nil {
            break
        }
        // Skip comments
        if _, ok := tok.(xml.Comment); ok {
            continue
        }
        // Skip whitespace-only char data
        if cd, ok := tok.(xml.CharData); ok {
            if strings.TrimSpace(string(cd)) == "" {
                continue
            }
        }
        encoder.EncodeToken(tok)
    }
    encoder.Flush()
    return out.String(), nil
}
// minifyXML("<a>\n  <b>1</b>\n</a>") → "<a><b>1</b></a>"

# Minify XML with xmllint (part of libxml2)
xmllint --noblanks input.xml > minified.xml

# Minify from stdin
echo '<root>
  <item>hello</item>
</root>' | xmllint --noblanks -
# → <?xml version="1.0"?><root><item>hello</item></root>

# Strip comments too (combine with sed or xmlstarlet)
xmlstarlet ed -d '//comment()' input.xml | xmllint --noblanks -

# Check size reduction
echo "Before: $(wc -c < input.xml) bytes"
echo "After:  $(xmllint --noblanks input.xml | wc -c) bytes"

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