titledborder - Normalización en DOM analizando con java-¿Cómo funciona?

titledborder java

Question

Vi la siguiente línea en el código para un analizador DOM en este tutorial .

doc.getDocumentElement().normalize();

¿Por qué hacemos esta normalización?
Leí los docs pero no pude entender una palabra.

Pone todos los nodos de texto en la profundidad completa del subárbol debajo de este nodo

De acuerdo, ¿puede alguien mostrarme (preferiblemente con una imagen) cómo se ve este árbol?

¿Puede alguien explicarme por qué se necesita la normalización?
¿Qué pasa si no nos normalizamos?

Answer 1

Como una extensión de la respuesta de @ JBNizet para usuarios más técnicos, aquí está la implementación de la interfaz org.w3c.dom.Node en com.sun.org.apache.xerces.internal.dom.ParentNode , le da una idea de cómo funciona realmente. .

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);
}

Atraviesa todos los nodos recursivamente y llama a kid.normalize()
Este mecanismo se invalida en 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);
 } 

Espero que esto te ahorre tiempo.

Answer 2

El resto de la frase es:

donde solo la estructura (por ejemplo, elementos, comentarios, instrucciones de procesamiento, secciones CDATA y referencias de entidades) separa los nodos de texto, es decir, no hay nodos de texto adyacentes ni nodos de texto vacíos.

Esto básicamente significa que el siguiente elemento XML

<foo>hello 
wor
ld</foo>

Podría representarse así en un nodo desnormalizado:

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

Cuando se normaliza, el nodo se verá así

Element foo
    Text node: "Hello world"

Y lo mismo ocurre con los atributos: <foo bar="Hello world"/> , comentarios, etc.

Answer 3

En simple, la normalización es la reducción de redundancias.
Ejemplos de redundancias:
a) espacios en blanco fuera de las etiquetas raíz / documento ( ... <document> </document> ... )
b) espacios en blanco dentro de la etiqueta inicial (< ... >) y la etiqueta final (</ ... >)
c) espacios en blanco entre los atributos y sus valores (es decir, espacios entre el nombre de clave y = " )
d) declaraciones de espacio de nombres superfluas
e) saltos de línea / espacios en blanco en los textos de atributos y etiquetas
f) comentarios etc ...