recursal/MDN huggingface dataset:
Console.count()
===============

Registra el número de veces que se llama a `count()`. Esta función toma como argumento opcional una `etiqueta`.

**Nota:** Esta característica está disponible en Web Workers

Si la `etiqueta` es colocada, esta funcion muestra el numeros de veces que `count()` ha sido utilizada con la misma etiqueta.

Si la `etiqueta` es omitida, la funcion registra el numero de veces que `count()` fue llamada en esta línea en particular.

Por ejemplo, en este código:


```js
var user = "";

function greet() {
  console.count();
  return "hi " + user;
}

user = "bob";
greet();
user = "alice";
greet();
greet();
console.count();
```


La salida de la consola va a mostrar algo como esto:
```

"<no label>: 1"
"<no label>: 2"
"<no label>: 3"
"<no label>: 1"
```


Note que al final de la linea de la salida: La llamada separada `count()` en la linea 11 es tratada como un evento independiente.

Si pasamos la variable `user` como `etiqueta` en la primera llamada a `count()` y la cadena "alice" en la segunda llamada:


```js
var user = "";

function greet() {
  console.count(user);
  return "hi " + user;
}

user = "bob";
greet();
user = "alice";
greet();
greet();
console.count("alice");
```


Vamos a ver una salida como esta:
```

"bob: 1"
"alice: 1"
"alice: 2"
"alice: 3"
```


Ahora tenemos diferentes contadores según el valor de la `etiqueta`. Al coincidir la etiqueta "alice" en la línea 11 con el valor de `user` dos veces, no se considera un evento independiente.

Sintaxis
--------
```

console.count([label]);
```

Parámetros
----------

`label`

Una cadena. Si se proporciona, la salida de `count()` indica el número de veces que fue llamada con la etiqueta. Si se omite, la salida de `count()` indica el número de veces que fue llamada en esa misma línea.

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

| Specification |
| --- |
| Console Standard # count |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Console.warn()
==============

Imprime un mensaje de advertencia en la Consola Web.

**Nota:** Esta característica está disponible en Web Workers

**Nota:** En Firefox, las advertencias tienen un pequeño icono de signo de exclamación junto a estas en el registro de la Consola Web.

Sintaxis
--------
```

console.warn(obj1 [, obj2, ..., objN]);
console.warn(msg [, subst1, ..., substN]);
```

Parámetros
----------

`obj1` ... `objN`

Una lista de objetos JavaScript para ser emitidos en la Consola Web. Las representaciones como string de cada uno de estos objetos son anexados juntos en el orden listado e impresos.

`msg`

Un string JavaScript que contiene cero o más strings de sustitución.

`subst1` ... `substN`

Objetos JavaScript con los cuales se reemplaza los strings de sustitución dentro de `msg`. Esto le proporciona un control adicional sobre el formato de salida.

Vea Outputting text to the console en la documentación de `console` para mas detalles.

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

| Specification |
| --- |
| Console Standard # warn |

Compatibilidad del Navegador
----------------------------

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

Ver también
-----------

* Opera Dragonfly documentation: Console
* MSDN: Using the F12 Tools Console to View Errors and Status
Console.info()
==============

Emite un mensaje informativo a la Consola Web. En Firefox y Chrome, se muestra un pequeño ícono "i" junto a estos elementos en el registro de la Consola Web.
**Nota:** Esta característica está disponible en Web Workers

Sintaxis
--------
```

console.info(obj1 [, obj2, ..., objN]);
console.info(msg [, subst1, ..., substN]);
```

Parametros
----------

`obj1` ... `objN`

Una lista de objetos JavaScript a la salida. Las representaciones de cadena de cada uno de estos objetos se anexan en el orden y salida.

`msg`

Un String en JavaScript contiene cero o mas strings de sustitucion

`subst1` ... `substN`

Objetos en JavaScript con los que reemplazar cadenas de sustitución dentro del mensaje. Esto le da un control adicional sobre el formato de la salida.

Ver Salida de texto en la consola en la documentacion de `console` para detalles.

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

| Specification |
| --- |
| Console Standard # info |

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

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

Vea tambien
-----------

* Opera Dragonfly documentation: Console
* MSDN: Using the F12 Tools Console to View Errors and Status
Console.trace()
===============

**No estándar:** Esta característica no es parte de los estándares. No la uses en sitios Web en producción: no funcionará para todos los usuarios. Podrían haber también incompatibilidades considerables entre distintas implementaciones y el comportamiento podría cambiar en el futuro.

Outputs a stack trace to the Web Console.

**Nota:** Esta característica está disponible en Web Workers

Ver Stack traces en la documentación de `console` para detalles y ejemplos.

Sintaxis
--------
```

console.trace();
```

Ejemplo
-------


```js
function foo() {
  function bar() {
    console.trace();
  }
  bar();
}

foo();
```


La siguiente indicador será mostrado en la consola:
```

bar
foo
<anonymous>
```

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

| Specification |
| --- |
| Console Standard # trace |

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

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

Ver tambien
-----------

* Opera Dragonfly documentation: Console
Blob.type
=========

La propiedad **`type`** de un objeto `Blob` proporciona el tipo MIME del archivo. Retorna una cadena vacía si el tipo no puede ser determinado.

Sintaxis
--------
```

var tipo = instanceOfFile.type
```

Valor
-----

Una cadena

Ejemplo
-------


```js
var i, fileInput, files, allowedFileTypes;

// fileInput es un HTMLInputElement: <input type="file" multiple id="myfileinput">
fileInput = document.getElementById("myfileinput");

// files es un objeto FileList (similar a NodeList)
files = fileInput.files;

// nuestra aplicacion solo acepta imagenes \*.png, \*.jpeg y \*.gif
allowedFileTypes = ["image/png", "image/jpeg", "image/gif"];

for (i = 0; i < files.length; i++) {
  // Prueba si file.type es un tipo de archivo permitido.
  if (allowedFileTypes.indexOf(files[i].type) > -1) {
    // El tipo de archivo es uno de los permitidos. Hacer algo aquí.
  }
});
```

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

| Specification |
| --- |
| File API # dfn-type |

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

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

Ver también
-----------

* `Blob`
Blob()
======

El constructor **`Blob()`** retorna un nuevo objeto `Blob` . El contenido del blob consiste en la concatenación de los valores obtenidos en el parrametro *array*.

Sintaxis
--------
```

var aBlob = new Blob( array, options );
```

### Parámetros

`array`

Es un `Array` de `ArrayBuffer`, `ArrayBufferView` (en-US), `Blob`, objetos `USVString` (en-US), o una mezcla de cualquiera de éstos objetos, que será puesto dentro de `Blob`. Los objetos `USVString` estan codificados como UTF-8.

`options` Opcional

Un objeto opcional de tipo `BlobPropertyBag` que puede especificar las siguientes propiedades:

`type` Opcional

El MIME type (en-US) de la información que será almacenada en el blob. El valor por defecto es una cadena vacía, (`""`).

`endings` Opcional 
Non-standard

Cómo interpretar los carácteres de nueva línea (`\n`) en el contenido, si la información es texto. El valor por defecto, `transparent`, copia los caracteres de nueva línea en el blob sin cambiarlos. Para convertir las nuevas líneas a la convención nativa del sistema, se especifica `endings`.


### Valor de retorno

Un nuevo objeto `Blob` conteniendo la información especificada.

Ejemplo
-------


```js
var unaParteDeArchivo = ['<a id="a"><b id="b">hey!</b></a>']; // un array de un solo DOMString
var oMiBlob = new Blob(unaParteDeArchivo, { type: "text/html" }); // el blob
```

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

| Specification |
| --- |
| File API # constructorBlob |

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

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

Vea también
-----------

* La interfaz deprecada `BlobBuilder`, la cual es reemplazada por este constructor.
WebSocket.onerror
=================

La propiedad **`WebSocket.onerror`**, del tipo `event handler`, será llamada cuando se dé un error. Esta llamada recibirá un tipo `Event` como argumento.

Sintaxis
--------
```

aWebSocket.onerror = function(event) {
  console.error("Error en el WebSocket detectado:", event);
};
```

Valor
-----

Un `EventListener`.

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

| Specification |
| --- |
| WebSockets Standard # dom-websocket-onerror |

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

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

El manejador `close` es ejecutado cuando una conexión con un websocket es cerrada.

General info
------------

Specification

WebSocket

Interface

Event

Bubbles

No

Cancelable

No

Target

WebSocket (en-US)

Default Action

None

Properties
----------

| Property | Type | Description |
| --- | --- | --- |
| `target` Read only  | `EventTarget` | El objetivo del evento (el objetivo superior en el árbol DOM). |
| `type` Read only  | `DOMString` | El tipo de evento. |
| `bubbles` Read only  | `Boolean` | Si el evento normalmente burbujea o no. |
| `cancelable` Read only  | `Boolean` | Si el evento es cancelable o no. |

Related Events
--------------

* `open`
* `close`
* `error` (en-US)
* `message`
See also
--------

* Writing WebSocket client applications (en-US)
Node.lastChild
==============

La propiedad de sólo lectura **`Node.lastChild`** devuelve el último hijo del nodo. Si su padre es un elemento, entonces el hijo es generalmente un nodo de element, nodo de texto o un nodo de comentario. Devuelve `null` si no hay elementos hijos.

Sintaxis
--------
```

var nodoHijo= nodo.lastChild;
```

Ejemplo
-------


```js
var tr = document.getElementById("row1");
var corner_td = tr.lastChild;
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-node-lastchild① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Node.isSameNode()
=================

 **Obsoleto:** Esta característica ya no se recomienda. Aunque es posible que algunos navegadores aún lo admitan, probablemente ya se ha eliminado de los estándares web relevantes, está en proceso de eliminación o solo se conserva por motivos de compatibilidad. Evite usarlo y actualice el código existente si es posible; consulte la tabla de compatibilidad en la parte inferior de esta página para orientar su decisión. Tenga en cuenta que esta característica puede dejar de funcionar en cualquier momento.

**`Node.isSameNode()`** comprueba si dos nodos son iguales, es decir si hacen referencia al mismo objecto.

**Advertencia:** This method is no longer implemented in recent browsers.


```js
// Instead of using
node1.isSameNode(node2);

// use
node1 === node2; // or
node1 == node2;
```


Sintaxis
--------
```

var isSameNode = node.isSameNode(other);
```


* `other` El nodo contra el cual se realiza la comparación.
Especificaciones
----------------

| Specification |
| --- |
| DOM Standard # dom-node-issamenode |

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

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

Ver además
----------

* `Node.isEqualNode()` (en-US)
element.nodeName
================

### Resumen

Devuelve el nombre del nodo actual, en forma de cadena.

### Sintaxis
```

var str = node.nodeName;
```


`str` es una variable de cadena en la que se almacena el nombre del elemento actual.

`nodeName` es un atributo de solo-lectura.

### Notas

Aquí tenemos el valor devuelto por varios tipos de nodo.

| Interfaz | nodeName |
| --- | --- |
| Attr | igual que `Attr.name` |
| CDATASection | "#cdata-section" |
| Comment | "#comment" |
| Document | "#document" |
| DocumentFragment | "#document-fragment" |
| DocumentType | igual que `DocumentType.name` |
| Element | igual que `Element.tagName` |
| Entity | nombre de entity |
| EntityReference | nombre de la identidad de referencia |
| Notation | nombre de la notación |
| ProcessingInstruction | igual que `ProcessingInstruction.target` |
| Text | "#text" |

### Ejemplo

Dado el siguiente código:
```

<div id="d1">hola mundo</div>
<input type="text" id="t"/>
```


y el siguiente script:
```

var div1 = document.getElementById("d1");
var text_field = document.getElementById("t");
text_field.value = div1.nodeName;
```


En XHTML (o alguna otra forma de XML) el valor de `text_field` será "div". Sin embargo, en HTML, el valor de `text_field` sería "DIV".

Ten en cuenta que podríamos haber usado la propiedad `tagName` en su lugar, ya que `nodeName` tiene el mismo valor que `tagName` para un elemento. Presta atención, sin embargo, a que `nodeName` devolverá `#text` para los nodos de texto, mientras que `tagName` devolverá `undefined`.

### Especificaciones

DOM Level 2 Core: Node.nodeName

DOM Level 3 Core: Node.nodeName
Nodo appendChild
================

Agrega un nuevo nodo al final de la lista de un elemento hijo de un elemento padre especificado.

Si el hijo(Child) **es una referencia**(hace referencia) hacia un nodo existente en el documento actual, este es quitado del padre actual para ser puesto en el nodo padre nuevo. La clave está en **si el (Child) es una referencia a un nodo existente en el documento**.

**Nota:** **Nueva API disponible**
 El método `ParentNode.append()` (en-US) soporta varios argumentos y cadenas para adjuntar.


Sintaxis
--------
```

element.appendChild(aChild);
```

### Parámetros

**aChild**

El nodo a adjuntar al nodo padre proporcionado (normalmente un elemento).

### Valor de retorno

El valor devuelto es el hijo adjunto excepto cuando el hijo proporcionado es un `DocumentFragment`, en cuyo caso el `DocumentFragment` vacío es devuelto.

Notas
-----

El encadenamiento podría no funcionar como se espera debido a que `appendChild()` devuelve un elemento hijo:


```js
var aBlock = doc.createElement("block").appendChild(doc.createElement("b"));
```


Establece `aBlock` como `<b></b>` sólo, que no es probablemente lo que quieras.

Si el `child` hace una referencia a un nodo existente en el documento, el método `appendChild` se mueve de su posición actual a su nueva posición (ej. no existen requerimientos para eliminar el nodo desde su nodo padre antes de añadirlo a cualquier otro nodo).

Ésto significa también que el nodo no puede estar en dos puntos del documento de manera simultánea. Así que si el nodo ya contiene un padre, primero es eliminado, y después se añade a la nueva posición.

Se puede usar `Node.cloneNode` para hacer una copia del nodo antes de añadirlo debajo de su nuevo elemento padre. (Nota: las copias echas con `cloneNode` no serán guardadas automáticamente en sincronía.)

 Éste método no es permitido para mover nodos entre distintos documentos. Si se quiere añadir un nodo desde un documento diferente (por ejemplo para mostrar los resultados de una petición AJAX) se debe usar primero:
 `document.importNode`.

`appendChild()` Es uno de los métodos fundamentales de la programación web usando el DOM. El método `appendChild()` inserta un nuevo nodo dentro de la estructura DOM de un documento, y es la segunda parte del proceso central uno-dos, crear-y-añadir para construir páginas web a base de programación.

Ejemplo
-------


```js
// Crea un nuevo elemento párrafo, y lo agrega al final del cuerpo del documento
var p = document.createElement("p");
document.body.appendChild(p);
```

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

| Specification |
| --- |
| DOM Standard # dom-node-appendchild |

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

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

Ver también
-----------

* `Node.removeChild`
* `Node.replaceChild`
* `Node.insertBefore`
* `Node.hasChildNodes`
* `ParentNode.append()` (en-US)
Node.nextSibling
================

La propiedad de sólo lectura **`Node.nextSibling`** devuelve el siguiente nodo con respecto al indicado en la lista de nodos (`childNodes`) a la que este pertenece o `null` si el nodo especificado es el último en dicha lista.

Sintaxis
--------
```

siguienteNodo = node.nextSibling
```

Notas
-----

 Gecko-based browsers insert text nodes into a document to represent whitespace in the source markup.
 Therefore a node obtained, for example, using `Node.firstChild` (en-US) or `Node.previousSibling` may refer to a
 whitespace text node rather than the actual element the author intended to get.

 See Whitespace in the DOM (en-US) and
 W3C DOM 3 FAQ: Why are some Text nodes empty?
 for more information.

`Element.nextElementSibling` debe ser utilizado para obtener el siguiente elemento ignorando cualquier nodo en blanco.

Ejemplo
-------


```html
<div id="div-01">Este es el div-01</div>
<div id="div-02">Este es el div-02</div>

<script type="text/javascript">
 var el = document.getElementById("div-01").nextSibling,
 i = 1;

 console.log("Hermanos de div-01:");

 while (el) {
 console.log(i + ". " + el.nodeName);
 el = el.nextSibling;
 i++;
 }
</script>

<!--
 Lo siguiente se escribe en la consola cuando carga:

 Nodos hermanos del div-01

 1. #text
 2. DIV
 3. #text
 4. SCRIPT

-->
```


En el ejemplo anterior, se puede observar que los nodos `#text` se insertan en el DOM, donde se produce un espacio en blanco en el marcado entre las etiquetas (es decir, después de la etiqueta de cierre de un elemento y antes de la etiqueta de apertura del siguiente). No se crea ningún espacio en blanco entre los elementos insertados por la sentencia `document.write`.

La posible inclusión de los nodos de texto en el DOM se debe permitir cuando se atraviese el DOM utilizando `nextSibling`. Vea los recursos en la sección Notas.

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-node-nextsibling① |

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

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

Ver también
-----------

* `Element.nextElementSibling`
Node: Método removeChild()
==========================

El método **`removeChild()`** de la interfaz `Node` elimina un nodo hijo del DOM y devuelve el nodo eliminado.

**Nota:** Mientras se mantenga una referencia sobre el elemento hijo eliminado, seguirá existiendo en la memoria, pero ya no forma parte del DOM. Todavía se puede reutilizar más adelante en el código.

Si el valor devuelto de `removeChild()` no se almacena y no se guarda ninguna otra referencia, se eliminará automáticamente de la memoria al cabo de un breve tiempo.

A diferencia de `Node.cloneNode()`, el valor devuelto conserva los objetos `EventListener` asociados con él.

Sintaxis
--------


```js
removeChild(child)
```

### Parámetros

`child`

Un `Node` que es el nodo hijo que se eliminará del DOM.

### Excepción

`NotFoundError` `DOMException`

Se lanza si `child` no es un hijo del nodo.

`TypeError`

Se lanza si `child` es `null`.

Ejemplos
--------

### Ejemplos simples

Dado este HTML:


```html
<div id="parent">
  <div id="child"></div>
</div>
```


Para eliminar un elemento específico cuando se conoce su nodo principal:


```js
const parent = document.getElementById("parent");
const child = document.getElementById("child");
const throwawayNode = parent.removeChild(child);
```


Para eliminar un elemento específico sin tener que especificar su nodo principal:


```js
const node = document.getElementById("child");
if (node.parentNode) {
  node.parentNode.removeChild(node);
}
```


Para eliminar todos los hijos de un elemento:


```js
const element = document.getElementById("idOfParent");
while (element.firstChild) {
  element.removeChild(element.firstChild);
}
```

### Causar un TypeError


```html
<!--Código HTML de muestra-->
<div id="parent"></div>
```



```js
const parent = document.getElementById("parent");
const child = document.getElementById("child");

// Arroja Uncaught TypeError
const garbage = parent.removeChild(child);
```

### Causar un NotFoundError


```html
<!--Código HTML de muestra-->
<div id="parent">
  <div id="child"></div>
</div>
```



```js
const parent = document.getElementById("parent");
const child = document.getElementById("child");

// Esta primera llamada elimina correctamente el nodo.
const garbage = parent.removeChild(child);

// Arroja NotFoundError
garbage = parent.removeChild(child);
```

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

| Specification |
| --- |
| DOM Standard # dom-node-removechild |

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

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

Véase también
-------------

* `Node.replaceChild()`
* `Node.parentNode`
* `Element.remove()`
* `Node.cloneNode()`
Node.nodeType
=============

La propiedad de solo lectura **`Node.nodeType`** retornará un valor positivo entero representando el tipo de nodo.Sintaxis
--------
```

var type = node.nodeType;
```


la variable type será un entero positivo con alguno de los siguientes valores:

| Name | Value |
| --- | --- |
| `ELEMENT_NODE` | `1` |
| `ATTRIBUTE_NODE` 
Obsoleto
 | `2` |
| `TEXT_NODE` (en-US) | `3` |
| `CDATA_SECTION_NODE` 
Obsoleto
 | `4` |
| `ENTITY_REFERENCE_NODE` 
Obsoleto
 | `5` |
| `ENTITY_NODE` 
Obsoleto
 | `6` |
| `PROCESSING_INSTRUCTION_NODE` (en-US) | `7` |
| `COMMENT_NODE` (en-US) | `8` |
| `DOCUMENT_NODE` | `9` |
| `DOCUMENT_TYPE_NODE` (en-US) | `10` |
| `DOCUMENT_FRAGMENT_NODE` | `11` |
| `NOTATION_NODE` 
Obsoleto
 | `12` |

Ejemplo
-------

Este es un ejemplo que verifica si el primer nodo dentro de un elemento tipo documento (document) es un comentario nodo, y si no lo es, muestra un mensaje.


```js
var node = document.documentElement.firstChild;
if (node.nodeType != Node.COMMENT\_NODE)
  console.log("You should comment your code well!");
```

Especificación
--------------

* DOM Level 2 Core: Node.nodeType
* DOM Level 3 Core: Node.nodeType
* DOM Standard
Node.contains()
===============

El método **`Node.contains()`** devuelve un valor `Boolean` indicando si un nodo es descendiente de un nodo dado o no, por ejemplo, el propio nodo, uno de sus hijos directos ((`childNodes`)), uno de los hijos directos de su nodo hijo, etc.

Sintaxis
--------
```

node.contains( otroNodo )
```

Ejemplo
-------

Esta función verifica si un un elemento esté en el cuerpo de la página. Como `contains` es inclusivo y determinar si el cuerpo se contiene a sí mismo no es la intención de `isInPage` este caso explícitamente devuelve `false`.


```js
function isInPage(node) {
  return node === document.body ? false : document.body.contains(node);
}
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-node-contains① |

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

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

Ver también
-----------

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