डोम में सामान्यीकरण जावा के साथ पार्सिंग - यह कैसे काम करता है?

Question

मैंने इस ट्यूटोरियल में DOM पार्सर के लिए कोड में नीचे की लाइन देखी ।

doc.getDocumentElement().normalize();

हम यह सामान्यीकरण क्यों करते हैं?
मैंने डॉक्स पढ़े लेकिन मैं एक शब्द नहीं समझ सका।

इस नोड के नीचे उप-वृक्ष की पूरी गहराई में सभी पाठ नोड्स डालता है

ठीक है, फिर कोई मुझे दिखा सकता है (अधिमानतः एक तस्वीर के साथ) यह पेड़ कैसा दिखता है?

क्या कोई मुझे समझा सकता है कि सामान्यीकरण की आवश्यकता क्यों है?
यदि हम सामान्य नहीं करते हैं तो क्या होता है?

Comments

आपके प्रश्न के बावजूद, कृपया उदाहरण पर नोट पढ़ें: "DOM पार्सर धीमा है और यह बहुत मेमोरी की खपत करेगा जब यह XML दस्तावेज़ को लोड करता है जिसमें बहुत अधिक डेटा होता है। कृपया SAX पार्सर को इसके लिए समाधान के रूप में मानें, SAX तेज है। DOM की तुलना में और कम मेमोरी का उपयोग करें। " ।

— wulfgarpro

@ wulfgar.pro - मैं समझता हूं कि आपने क्या कहा। लेकिन, मैं प्रश्न में पूछे गए सामान को समझना चाहता हूं। मैं जल्द ही SAX पार्सिंग भी करूंगा।

— Apple Grinder

"सामान्यीकृत xml" के लिए Google पर खोज करने से कुछ परिणाम मिले जो उपयोगी लगते हैं। यह डेटाबेस में सामान्यीकरण के समान ही दिखता है।

— Apple Grinder

@ ईजेपी - उम ... इसकी अभी भी स्पष्ट नहीं है क्योंकि मैं गहराई में xml नहीं जानता और मैं केवल इसके बारे में कुछ परिचयात्मक पृष्ठ पढ़ता हूं। BTW, मुझे गलत मत समझो, तुमने बिल्कुल वही किया जो डॉक्टर के लेखक ने किया - सादे अंग्रेजी के बजाय जटिल शब्दों का उपयोग करना (एक पाइक स्टाफ के रूप में सादा = समझने में आसान)। सरल शब्द पहले और शब्दजाल बाद में मेरे लिए बेहतर काम करता है।

— Apple Grinder

इस लेखन के रूप में संदर्भित वेबसाइट इस एसओ पोस्ट को संदर्भित कर रही है। मेरे मस्तिष्क ने सिर्फ एक निर्भरता त्रुटि फेंक दी।

— चेसोफनरड

Answer 1

शेष वाक्य है:

जहां केवल संरचना (जैसे, तत्व, टिप्पणियां, प्रसंस्करण निर्देश, सीडीएटीए अनुभाग, और इकाई संदर्भ) पाठ नोड्स को अलग करता है, अर्थात, न तो आसन्न पाठ नोड्स हैं और न ही खाली पाठ नोड्स।

इसका मूल रूप से मतलब है कि निम्न XML तत्व

<foo>hello 
wor
ld</foo>

एक निरंकुश नोड में इस तरह का प्रतिनिधित्व किया जा सकता है:

Element foo
    Text node: ""
    Text node: "Hello "
    Text node: "wor"
    Text node: "ld"

जब सामान्य किया जाता है, तो नोड इस तरह दिखेगा

Element foo
    Text node: "Hello world"

और एक ही गुण के लिए जाता है:, <foo bar="Hello world"/>टिप्पणी, आदि

Comments

अहा! अब यह बहुत स्पष्ट है। मैं डेटा संरचनाओं (???) और नोड्स के बारे में नहीं जानता। लेकिन मुझे पेड़ की संरचना पर एक त्वरित नज़र थी और, मैं अनुमान लगा रहा हूं कि आपके द्वारा सुझाए गए तरीके से एक कंप्यूटर "हैलो वर्ल्ड" को स्टोर कर सकता है। क्या वह सही है ?

— Apple Grinder

आपको DOM के बारे में मूल बातें सीखने की जरूरत है। हां, DOM ट्री के रूप में XML डॉक्यूमेंट का प्रतिनिधित्व करता है। और एक पेड़ में, आपके पास बाल नोड वाले रूट नोड होते हैं, प्रत्येक बच्चे के नोड में भी बच्चे के नोड्स होते हैं, आदि यही एक पेड़ है। तत्व एक प्रकार का नोड है, और टेक्स्टनोड एक अन्य प्रकार का नोड है।

— जेबी निज़ेट

धन्यवाद जेबी निजेट आपको बता नहीं सकता कि कुछ दिशा मिलने के बाद मुझे कितनी राहत मिली।

— Apple ग्राइंडर

@ user2043553, newlines वास्तव में वहाँ बिंदु हैं। Newlines के बिना, आप अंतर नहीं देखेंगे। यदि आपको समझ में नहीं आया है: XML को सामान्यीकरण "सही" करता है तो एक टैग को एक तत्व के रूप में व्याख्या की जाती है। यदि आपने ऐसा नहीं किया है, तो ऐसा हो सकता है कि ये बहुत ही नई सुर्खियों में एक ही प्रकार के कई तत्वों (एक ही टैग में) के बीच परिसीमन के रूप में व्याख्या की जाती हैं।

— स्टिकी

@Stacky, उदाहरण में दो नई लाइनें हैं, उन्हें उदाहरण में सामान्य करने के बाद प्रदर्शित नहीं किया जाता है, जिससे लोगों को यह विश्वास हो सकता है कि अब वहाँ नहीं हैं। प्रदर्शित किए गए नएलाइन के साथ परिणामी टेक्स्ट नोड इस तरह दिखाई देगा: "हेलो \ nwor \ nld" सामान्यीकरण नईलाइन्स को नहीं हटाता है।

— क्रिश्चियन

Answer 2

साधारण तौर पर, सामान्यीकरण अतिरेक की कमी है।
अतिरेक के उदाहरण:
ए) रूट / दस्तावेज़ टैग के बाहर सफेद रिक्त स्थान ( ... <दस्तावेज़> </ दस्तावेज़> ... )
बी) प्रारंभ टैग (< ... >) और अंत टैग के भीतर सफेद रिक्त स्थान (</ ... >)
ग) गुण और के बीच उनके मूल्यों (यानी। रिक्त स्थान के बीच सफेद रिक्त स्थान कुंजी नाम और = " )
घ) ज़रूरत से ज़्यादा नाम स्थान घोषणाओं
ई) विशेषताओं के ग्रंथों और टैग में पंक्ति विराम / सफेद रिक्त स्थान
च) टिप्पणी आदि ...

Answer 3

अधिक तकनीकी उपयोगकर्ताओं के लिए @ JBNizet के जवाब के विस्तार के रूप में यहाँ पर org.w3c.dom.Nodeइंटरफ़ेस का कार्यान्वयन com.sun.org.apache.xerces.internal.dom.ParentNodeकैसा दिखता है, आपको यह विचार देता है कि वास्तव में यह कैसे काम करता है।

public void normalize() {
    // No need to normalize if already normalized.
    if (isNormalized()) {
        return;
    }
    if (needsSyncChildren()) {
        synchronizeChildren();
    }
    ChildNode kid;
    for (kid = firstChild; kid != null; kid = kid.nextSibling) {
         kid.normalize();
    }
    isNormalized(true);
}

यह सभी नोड्स को पुनरावर्ती बनाता है और कॉल kid.normalize()
करता हैorg.apache.xerces.dom.ElementImpl

public void normalize() {
     // No need to normalize if already normalized.
     if (isNormalized()) {
         return;
     }
     if (needsSyncChildren()) {
         synchronizeChildren();
     }
     ChildNode kid, next;
     for (kid = firstChild; kid != null; kid = next) {
         next = kid.nextSibling;

         // If kid is a text node, we need to check for one of two
         // conditions:
         //   1) There is an adjacent text node
         //   2) There is no adjacent text node, but kid is
         //      an empty text node.
         if ( kid.getNodeType() == Node.TEXT_NODE )
         {
             // If an adjacent text node, merge it with kid
             if ( next!=null && next.getNodeType() == Node.TEXT_NODE )
             {
                 ((Text)kid).appendData(next.getNodeValue());
                 removeChild( next );
                 next = kid; // Don't advance; there might be another.
             }
             else
             {
                 // If kid is empty, remove it
                 if ( kid.getNodeValue() == null || kid.getNodeValue().length() == 0 ) {
                     removeChild( kid );
                 }
             }
         }

         // Otherwise it might be an Element, which is handled recursively
         else if (kid.getNodeType() == Node.ELEMENT_NODE) {
             kid.normalize();
         }
     }

     // We must also normalize all of the attributes
     if ( attributes!=null )
     {
         for( int i=0; i<attributes.getLength(); ++i )
         {
             Node attr = attributes.item(i);
             attr.normalize();
         }
     }

    // changed() will have occurred when the removeChild() was done,
    // so does not have to be reissued.

     isNormalized(true);
 } 

आशा है कि यह आपको कुछ समय बचाता है।