Node
====

 La interfaz DOM **`Node`** es una clase base abstracta en la que se basan muchos otros objetos de la API DOM, lo que permite que esos tipos de objetos se usen de manera similar y, a menudo, intercambiable.
 Como clase abstracta, no existe tal cosa como un simple objeto `Node`. Todos los objetos que implementan la funcionalidad `Node` se basan en una de sus subclases. Los más notables son `Document`, `Element` y `DocumentFragment`.

 Además, cada tipo de nodo de DOM está representado por una interfaz basada en `Node`.
 Estos incluyen `Attr`, `CharacterData` (en-US) (en los que `Text` (en-US), `Comment`, `CDATASection` (en-US) y `ProcessingInstruction` (en-US) están basados) y `DocumentType` (en-US).

En algunos casos, es posible que una característica particular de la interfaz base `Node` no se aplique a una de sus interfaces secundarias; en ese caso, el nodo heredero puede devolver `null` o generar una excepción, según las circunstancias. Por ejemplo, intentar agregar elementos secundarios a un tipo de nodo que no puede tener elementos secundarios generará una excepción.

EventTarget

NodePropiedades de instancia
------------------------

*Además de las propiedades a continuación, `Node` hereda propiedades de su padre, `EventTarget`.*

`Node.baseURI` (en-US) Read only 

Devuelve una cadena que representa la URL base del documento que contiene el `Node`.

`Node.childNodes` Read only 

Devuelve un `NodeList` en vivo que contiene todos los elementos secundarios de este nodo (incluidos elementos, texto y comentarios). Un `NodeList` en vivo significa que si los hijos de `Node` cambian, el objeto `NodeList` se actualiza automáticamente.

`Node.firstChild` (en-US) Read only 

Devuelve un `Node` que representa el primer nodo hijo directo del nodo, o `null` si el nodo no tiene ningún hijo.

`Node.isConnected` (en-US) Read only 

Un valor booleano que indica si el nodo está conectado o no (directa o indirectamente) al objeto de contexto, por ejemplo el objeto `Document` en el caso del DOM normal, o `ShadowRoot` (en-US) en el caso de un DOM oculto.

`Node.lastChild` Read only 

Devuelve un `Node` que representa el último nodo hijo directo del nodo, o `null` si el nodo no tiene ningún hijo.

`Node.nextSibling` Read only 

Devuelve un `Node` que representa el siguiente nodo en el árbol, o `null` si no existe tal nodo.

`Node.nodeName` Read only 

Devuelve una cadena que contiene el nombre de `Node`. La estructura del nombre diferirá con el tipo de nodo. Por ejemplo, un `HTMLElement` contendrá el nombre de la etiqueta correspondiente, como `'audio'` para un `HTMLAudioElement`, un `Text` (en-US) tendrá la cadena `'#text'`, o un nodo `Document` tendrá la cadena `'#document'`.

`Node.nodeType` Read only 

Devuelve un `unsigned short` que representa el tipo del nodo. Los valores posibles son:

| Nombre | Valor |
| --- | --- |
| `ELEMENT_NODE` | `1` |
| `ATTRIBUTE_NODE` | `2` |
| `TEXT_NODE` | `3` |
| `CDATA_SECTION_NODE` | `4` |
| `PROCESSING_INSTRUCTION_NODE` | `7` |
| `COMMENT_NODE` | `8` |
| `DOCUMENT_NODE` | `9` |
| `DOCUMENT_TYPE_NODE` | `10` |
| `DOCUMENT_FRAGMENT_NODE` | `11` |

`Node.nodeValue`

Devuelve/Establece el valor del nodo actual.

`Node.ownerDocument` Read only 

Devuelve el `Document` al que pertenece este nodo. Si el nodo es en sí mismo un documento, devuelve `null`.

`Node.parentNode` Read only 

Devuelve un `Node` que es el padre de este nodo. Si no existe tal nodo, como si este nodo es la parte superior del árbol o si no participa en un árbol, esta propiedad devuelve `null`.

`Node.parentElement` Read only 

Devuelve un `Element` que es el padre de este nodo. Si el nodo no tiene padre, o si ese padre no es `Element`, esta propiedad devuelve `null`.

`Node.previousSibling` Read only 

Devuelve un `Node` que representa el nodo anterior en el árbol, o `null` si no existe tal nodo.

`Node.textContent`

Devuelve/Establece el contenido textual de un elemento y todos sus descendientes.

Métodos de instancia
--------------------

*Además de los métodos a continuación, `Node` hereda métodos de su padre, `EventTarget`.*

`Node.appendChild()`

Agrega el argumento `childNode` especificado como el último hijo del nodo actual. Si el argumento hace referencia a un nodo existente en el árbol DOM, el nodo se separará de su posición actual y se adjuntará a la nueva posición.

`Node.cloneNode()`

Clona un `Node` y, opcionalmente, todo su contenido. Por defecto, clona el contenido del nodo.

`Node.compareDocumentPosition()` (en-US)

Compara la posición del nodo actual con otro nodo en cualquier otro documento.

`Node.contains()`

Devuelve el valor `true` o `false` que indica si un nodo es o no descendiente del nodo que llama.

`Node.getRootNode()` (en-US)

Devuelve la raíz del objeto de contexto que, opcionalmente, incluye la raíz oculta si está disponible.

`Node.hasChildNodes()`

Devuelve un valor booleano que indica si el elemento tiene o no nodos secundarios.

`Node.insertBefore()`

Inserta un `Node` antes del nodo de referencia como hijo de un nodo principal especificado.

`Node.isDefaultNamespace()` (en-US)

Acepta un URI de espacio de nombres como argumento y devuelve un valor booleano con un valor de `true` si el espacio de nombres es el espacio de nombres predeterminado en el nodo dado o `false` si no lo es.

`Node.isEqualNode()` (en-US)

Devuelve un valor booleano que indica si dos nodos son o no del mismo tipo y todos los puntos de datos que los definen coinciden.

`Node.isSameNode()`

Devuelve un valor booleano que indica si los dos nodos son iguales o no (es decir, hacen referencia al mismo objeto).

`Node.lookupPrefix()` (en-US)

Devuelve una cadena que contiene el prefijo para un URI de espacio de nombres dado, si está presente, y `null` si no lo está. Cuando son posibles varios prefijos, el resultado depende de la implementación.

`Node.lookupNamespaceURI()` (en-US)

Acepta un prefijo y devuelve el URI del espacio de nombres asociado con él en el nodo dado si lo encuentra (y `null` si no). Proporcionar `null` para el prefijo devolverá el espacio de nombres predeterminado.

`Node.normalize()` (en-US)

Limpia todos los nodos de texto debajo de este elemento (combina adyacentes, elimina vacíos).

`Node.removeChild()`

Elimina un nodo hijo del elemento actual, que debe ser uns hijo del nodo actual.

`Node.replaceChild()`

Reemplaza un `Node` hijo del actual con el segundo dado en el parámetro.

Ejemplos
--------

### Eliminar todos los hijos anidados dentro de un nodo

Esta función elimina cada primer hijo de un elemento, hasta que no quede ninguno.


```js
function removeAllChildren(element) {
  while (element.firstChild) {
    element.removeChild(element.firstChild);
  }
}
```


El uso de esta función es una sola llamada. Aquí vaciamos el cuerpo del documento:


```js
removeAllChildren(document.body);
```


Una alternativa podría ser establecer `textContent` a una cadena vacía: `document.body.textContent = ""`.

### Recursión a través de nodos hijos

La siguiente función llama recursivamente a una función *callback* para cada nodo contenido en un nodo raíz (incluida la propia raíz):


```js
function eachNode(rootNode, callback) {
  if (!callback) {
    const nodes = [];
    eachNode(rootNode, (node) => {
      nodes.push(node);
    });
    return nodes;
  }

  if (callback(rootNode) === false) {
    return false;
  }

  if (rootNode.hasChildNodes()) {
    for (const node of rootNode.childNodes) {
      if (eachNode(node, callback) === false) {
        return;
      }
    }
  }
}
```


La función llama recursivamente a una función para cada nodo descendiente de `rootNode` (incluida la propia raíz).

Si se omite `callback`, la función devuelve `Array` en su lugar, que contiene `rootNode` y todos los nodos contenidos dentro.

Si se proporciona `callback` y devuelve `false` cuando se llama, el nivel de recurrencia actual se aborta y la función reanuda la ejecución en el nivel del último padre. Esto se puede usar para abortar bucles una vez que se ha encontrado un nodo (como buscar un nodo de texto que contiene una determinada cadena).

La función tiene dos parámetros:

`rootNode`

El objeto `Node` cuyos descendientes serán recursivos.

`callback` Opcional

Una función *callback* opcional que recibe un `Node` como único argumento. Si se omite, `eachNode` devuelve un `Array` de cada nodo contenido dentro de `rootNode` (incluida la propia raíz).

Lo siguiente demuestra un uso real de la función `eachNode()`: buscar texto en una página web.

Usamos una función contenedora llamada `grep` para hacer la búsqueda:


```js
function grep(parentNode, pattern) {
  let matches = [];
  let endScan = false;

  eachNode(parentNode, (node) => {
    if (endScan) {
      return false;
    }

    // Ignora cualquier cosa que no sea un nodo de texto
    if (node.nodeType !== Node.TEXT\_NODE) {
      return;
    }

    if (typeof pattern === "string" && node.textContent.includes(pattern)) {
      matches.push(node);
    } else if (pattern.test(node.textContent)) {
      if (!pattern.global) {
        endScan = true;
        matches = node;
      } else {
        matches.push(node);
      }
    }
  });

  return matches;
}
```

Especificaciones
----------------

| Specification |
| --- |
| DOM Standard # interface-node |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.