recursal/MDN huggingface dataset:
Error.prototype.name
====================

La propiedad **`name`** representa un nombre para el tipo de error. El valor inicial es "Error".

Descripción
-----------

De forma predeterminada, las instancias `Error` reciben el nombre "Error". La propiedad `name`, además de la propiedad `message`, la utiliza el método `Error.prototype.toString()` para crear una representación de cadena del error.

Ejemplos
--------

### Lanzar un error personalizado


```js
var e = new Error("Entrada mal formada"); // e.name es 'Error'

e.name = "ParseError";
throw e;
// e.toString() devolverá 'ParseError: Entrada mal formada'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error.prototype.name |

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

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

Ve también
----------

* `Error.prototype.message`
* `Error.prototype.toString()`
TypeError() constructor
=======================

El constructor **`TypeError()`** crea un nuevo error cuando una operación no puede ser realizada, típicamente (pero no exclusivamente) cuando un valor no es del tipo esperado.

Sintaxis
--------


```js
new TypeError();
new TypeError(message);
new TypeError(message, fileName);
new TypeError(message, fileName, lineNumber);
```

### Parámetros

`message` Opcional

Descripción del error humanamente legible.

`options` Opcional

Un objeto con las siguientes propiedades:

`cause` Opcional

 Una propiedad que indica la causa específica del error.
 Cuando se atrapa y relanza un error con un mensaje de error más especifico o útil, esta propiedad debe ser usada para pasar el error original.



`fileName` Opcional 
Non-standard

El nombre del archivo contenedor del código que causa el error.

`lineNumber` Opcional 
Non-standard

El número de la línea que contiene el código causante del error.

Ejemplos
--------

### Atrapando un TypeError


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // Respuesta: true
  console.log(e.message); // Respuesta: "null has no properties"
  console.log(e.name); // Respuesta: "TypeError"
  console.log(e.fileName); // Respuesta: "Scratchpad/1"
  console.log(e.lineNumber); // Respuesta: 2
  console.log(e.columnNumber); // Respuesta: 2
  console.log(e.stack); // Respuesta: "@Scratchpad/2:2:3\n"
}
```

### Crear un TypeError


```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // Respuesta: true
  console.log(e.message); // Respuesta: "Hello"
  console.log(e.name); // Respuesta: "TypeError"
  console.log(e.fileName); // Respuesta: "someFile.js"
  console.log(e.lineNumber); // Respuesta: 10
  console.log(e.columnNumber); // Respuesta: 0
  console.log(e.stack); // Respuesta: "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

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

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

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

* `Error`
Set.prototype.values()
======================

El método **`values()`** retorna un objeto de tipo `Iterator` que contiene los valores para cada elemento en el objecto `Set` en orden de inserción.

El metodo **`keys()`** es un alias para este metodo (por similaridad con objetos `Map` (en-US)); se comporta exactamente igual y retorna **valores** para cada elemento de un `Set`.

Pruébalo
--------

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

mySet.values();
```

### Return value

Un nuevo objeto **`Iterator`** que contiene los valores para cada elemento en el `Set` dado, en orden de inserción.

Examples
--------

### Using `values()`


```js
var mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

var setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

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

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

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

* `Set.prototype.entries()`
Set.prototype[@@iterator]()
===========================

El valor inicial de la propiedad **`@@iterator`**, es la misma función objeto que el valor inicial de la propiedad `values`.

Pruébalo
--------

El código fuente de este ejemplo interactivo lo puedes encontrar en el repositorio de Github. Si quieres contribuir con más ejemplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envíanos una pull request.

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

mySet[Symbol.iterator]
```

### Valor retornado

La función **iteradora** `Set` , la cuál es `values()` por defecto.

Ejemplos
--------

### Usando `[@@iterator]()`


```js
const mySet = new Set();
mySet.add("0");
mySet.add(1);
mySet.add({});

const setIter = mySet[Symbol.iterator]();

console.log(setIter.next().value); // "0"
console.log(setIter.next().value); // 1
console.log(setIter.next().value); // Object
```

### Usando `[@@iterator]()` con `for..of`


```js
const mySet = new Set();
mySet.add("0");
mySet.add(1);
mySet.add({});

for (const v of mySet) {
  console.log(v);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype-@@iterator |

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

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

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

* `Set.prototype.entries()`
* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`
Set.prototype.size
==================

La propiedad de acceso **`size`** devuelve el número de elementos que hay en el objeto `Set`.

Descripción
-----------

El valor de `size` es un entero que representa cuantas entradas tiene el objeto `Set`. La función de accesso set para `size` es `undefined`; no se puede cambiar esta propiedad.

Ejemplos
--------

### Usando `size`


```js
var mySet = new Set();
mySet.add(1);
mySet.add(5);
mySet.add("un texto");

mySet.size; // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-set.prototype.size |

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

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

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

* `Set`
Set.prototype.entries()
=======================

El método **`entries()`** devuelve un nuevo objeto de tipo `Iterator` que contiene **un array de tuplas `[value, value]`** por cada elemento en el `Set` original, manteniendo el orden de inserción. En los objetos de tipo `Set` no existe una clave key como ocurre en los objetos de tipo `Map`. Sin embargo, para mantener una API similar a la de los objetos de tipo `Map`, cada *entry* contiene el mismo valor para su clave y valor, devolviendo por tanto un array de tuplas `[value, value]`.

Pruébalo
--------

El código de este ejemplo interactivo esta almacenado en un repositorio de GitHub. Si quieres contribuir al proyecto de ejemplos interativos, simplemente clona https://github.com/mdn/interactive-examples y envíanos una pull request.

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

mySet.entries()
```

### Valor de retorno

Un nuevo objeto de tipo `Iterator` que contiene un array de tuplas `[value, value]` por cada elemento en el `Set` original, en orden de inserción.

Ejemplos
--------

### Usando el método `entries`


```js
var mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

var setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

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

* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`
Set.prototype.clear()
=====================

El método **`clear()`** remueve todos los elementos de un objeto `Set`.

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

mySet.clear();
```

### Valor de retorno

`undefined`.

Ejemplos
--------

### Usando el método clear


```js
var mySet = new Set();
mySet.add(1);
mySet.add("foo");

mySet.size; // 2
mySet.has("foo"); // true

mySet.clear();

mySet.size; // 0
mySet.has("bar"); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

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

* `Set`
* `Set.prototype.delete()`
Set.prototype.delete()
======================

El método **`delete()`** remueve el elemento especificado del objeto `Set`.

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

mySet.delete(value);
```

### Parametros

valor

Requerido. El valor del elemento a remover del objeto `Set`.

### Valor de retorno

`true` si el elemento ha sido removido exitosamente en el `Set`; de otra manera retorna `false`.

Ejemplos
--------

### Usando el método `delete`


```js
var mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // Retorna false. No hay elemento "bar" para ser removido.
mySet.delete("foo"); // Retorna true. Removido exitosamente.

mySet.has("foo"); // Retorna false. El elemento "foo" ya no está presente.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

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

* `Set`
* `Set.prototype.clear()`
Set.prototype.add()
===================

El método **`add()`** añade un nuevo elemento con un valor específico al final del objeto `Set`.

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

mySet.add(value);
```

### Parameters

value

Requerido. El valor del elemento a ser añadido al objeto `Set`.

### Return value

El objeto `Set`.

Ejemplos
--------

### Usando el método add


```js
var mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // chainable

console.log(mySet);
// Set [1, 5, "some text"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

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

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

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

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`
Set.prototype.has()
===================

El método **`has()`** retorna un booleano indicando si el elemento especificado existe en el objeto `Set` o no.

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

mySet.has(value);
```

### Parametros

valor

Requerido. El valor del cual se probará su presencia en el objeto `Set`.

### Valor de retorno

Booleano

Retorna `true` si el elemento con el valor especificado existe en el objeto `Set`; de otra manera retorna `false`.

Ejemplos
--------

### Usando el método `has`


```js
var mySet = new Set();
mySet.add("foo");

mySet.has("foo"); // retorna true
mySet.has("bar"); // retorna false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

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

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`
Promise.prototype.finally()
===========================

El método **`finally()`** devuelve una `Promise`. Cuando la promesa se resuelve, sea exitosa o rechazada, la función de callback específicada será ejecutada. Esto ofrece una forma de ejecutar código sin importar como se haya resuelto la promesa.

Esto ayuda a evitar tener código duplicado tanto en el `then()` como en el `catch()`.

Sintaxis
--------


```js
p.finally(alFinalizar);

p.finally(function () {
  // finalizada (exitosa o rechazada)
});
```

### Parámetros

`alFinalizar`

Una `Function` llamada cuando la `Promise` se resuelve con éxito o falla.

### Valor de retorno

Devuelve una `Promise` cuyo `finally` fue fijado a la función específicada en `alFinalizar`.

Descripción
-----------

El método `finally()` puede ser de utilidad si quieres hacer algún proceso o limpieza una vez que la promesa termina, sin importar su resultado.

Utilizar `finally()` es muy similar a llamar `.then(onFinally, onFinally)`, sin embargo tiene algunas diferencias:

* Cuando usamos una función `inline`, se la puede pasar una sola vez, en vez de estar forzado a declararla dos veces, o guardarla en una variable.
* Un callback `finally` no recibe ningún argumento, ya que no hay una manera fehaciente de determinar si la promesa fue exitosa o fallida. Este caso de uso es precisamente para cuando *no nos importa* la razón por la que falló o el valor al que resuelve, y no hay necesidad de proveerlos.
* A diferencia de `Promise.resolve(2).then(() => {}, () => {})` (que va a resolver a `undefined`), `Promise.resolve(2).finally(() => {})` resolverá con un `2`.
* Del mismo modo, a diferencia de `Promise.reject(3).then(() => {}, () => {})` (que resolverá con `undefined`), `Promise.reject(3).finally(() => {})` será rechazada con un `3`.

**Nota:** Un `throw` (o retornar una promesa rechazada) en el callback `finally` va a rechazar la nueva promesa con la razón de rechazo especificada al llamar `throw()`.

Ejemplos
--------


```js
let isLoading = true;

fetch(myRequest)
  .then(function (response) {
    var contentType = response.headers.get("content-type");
    if (contentType && contentType.includes("application/json")) {
      return response.json();
    }
    throw new TypeError("Oops, no hemos obtenido un JSON!");
  })
  .then(function (json) {
    /\* procesar el JSON \*/
  })
  .catch(function (error) {
    console.log(
      error,
    ); /\* esta línea podría arrojar error, e.g. cuando console = {} \*/
  })
  .finally(function () {
    isLoading = false;
  });
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.finally |

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

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

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

* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()`
Promise.race()
==============

El método **`Promise.race(iterable)`** retorna una promesa que se cumplirá o no tan pronto como una de las promesas del argumento iterable se cumpla o se rechace, con el valor o razón de rechazo de ésta.

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

Promise.race(iterable);
```

### Parámetros

iterable

Un objeto iterable , como por ejemplo un `Array`. Vea iterable (en-US).

### Retorna

Una `Promise` que se cumple o se rechaza tan pronto como una de las promesas dadas en el argumento iterable se cumple o se rechaza.

Descripción
-----------

La función `race` retorna una `Promise` que se comporta como tal. Se cumple o se rechaza, lo que suceda antes en alguno de sus argumentos (iterable).

Ejemplos
--------

### Usando `Promise.race` – ejemplos con `setTimeout`


```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, "uno");
});
var p2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "dos");
});

Promise.race([p1, p2]).then((value) => {
  console.log(value); // "dos"
  // Ambas se resuelven, pero la p2 antes.
});

// Ejemplo con un resolve y un reject en el mismo método race.
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "tres");
});
var p4 = new Promise((resolve, reject) => {
  setTimeout(reject, 500, "cuatro");
});

Promise.race([p3, p4]).then(
  (value) => {
    console.log(value); // "tres"
    // p3 es mas rápida, así que se resuelve el race
  },
  (reason) => {
    // No es llamado
  },
);

var p5 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, "cinco");
});
var p6 = new Promise((resolve, reject) => {
  setTimeout(reject, 100, "seis");
});

Promise.race([p5, p6]).then(
  (value) => {
    // No es llamado
  },
  (reason) => {
    console.log(reason); // "seis"
    // p6 es mas rápida, así que se rechaza
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.race |

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

* `Promise`
* `Promise.all()`
Promise.all()
=============

El método **`Promise.all(iterable)`** devuelve una promesa que termina correctamente cuando todas las promesas en el argumento iterable han sido concluídas con éxito, o bien rechaza la petición con el motivo pasado por la primera promesa que es rechazada.

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

Promise.all(iterable);
```


iterable

Un objeto iterable, por ejemplo un `Array`. Vea iterable (en-US).

### Valor devuelto

Una `Promise` que se cumplirá cuando todas las promesas del argumento iterable hayan sido cumplidas, o bien se rechazará cuando alguna de ellas se rechace.

Descripción
-----------

**`Promise.all`** se cumple cuando todas las promesas del iterable dado se han cumplido, o es rechazada si alguna promesa no se cumple. `Promise.resolve`.

Si alguna de las promesas pasadas en el argumento iterable falla, la promesa `all` es rechazada inmediatamente con el valor de la promesa que fué rechazada, descartando todas las demás promesas hayan sido o no cumplidas. Si se pasa un array vacío a `all` , la promesa se cumple inmediatamente.

Ejemplos
--------

### Uso de `Promise.all`

`Promise.all` espera a que todo se cumpla (o bien al primer rechazo).


```js
var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "foo");
});

Promise.all([p1, p2, p3]).then((values) => {
  console.log(values); // [3, 1337, "foo"]
});
```

### `Promise.all` comportamiento de fallo-rápido

`Promise.all` se rechaza si uno de los elementos ha sido rechazado y `Promise.all` falla rápido: Si tienes cuatro promesas que se resuelven después de un timeout y una de ellas falla inmediatamente, entonces `Promise.all` se rechaza inmediatamente.


```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 1000, "one");
});
var p2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 2000, "two");
});
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 3000, "three");
});
var p4 = new Promise((resolve, reject) => {
  setTimeout(resolve, 4000, "four");
});
var p5 = new Promise((resolve, reject) => {
  reject("reject");
});

Promise.all([p1, p2, p3, p4, p5]).then(
  (values) => {
    console.log(values);
  },
  (reason) => {
    console.log(reason);
  },
);

//From console:
//"reject"

// Evenly, it's possible to use .catch
Promise.all([p1, p2, p3, p4, p5])
  .then((values) => {
    console.log(values);
  })
  .catch((reason) => {
    console.log(reason);
  });

//From console:
//"reject"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.all |

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

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

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

* `Promise`
* `Promise.race()`
Promise.reject()
================

El método **`Promise.reject(reason)`** retorna un objeto `Promise` que es rechazado por la razón específicada.

Pruébalo
--------

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

Promise.reject(reason);
```

### Parámetros

reason

Razón por la cual esta {jsxref("Promise")}} fue rechazada.

### Return value

Un objeto `Promise` que es rechazado por la razón específicada.

Descripción
-----------

La función estática `Promise.reject` retorna un objecto `Promise` que es rechazado. Para fines de depuración y captura selectiva de error, se suele pasar por el parámetro `reason` un `instanceof` `Error`.

Ejemplos
--------

### Usando el método estático Promise.reject()


```js
Promise.reject(new Error("fail")).then(
  function () {
    // no entra en esta función
  },
  function (error) {
    console.log(error); // Stacktrace
  },
);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

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

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

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

* `Promise`
* Selective error catching using the BlueBird Promise library
JSON.parse()
============

Resumen
-------

El método **`JSON.parse()`** analiza una cadena de texto como JSON, transformando opcionalmente el valor producido por el análisis.

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

JSON.parse(text[, reviver])
```

### Parámetros

`text`

El texto que se convertirá a JSON. Vea el objeto `JSON` para una descripción de la sintaxis JSON.

`reviver` Opcional

Si una función, prescribe cómo se transforma el valor producido originalmente por el parsing, antes de retornar.

### Returns

Retorna el objeto que se corresponde con el texto JSON entregado.

### Exceptions

Lanza una excepción `SyntaxError` si la cadena a transformar no es un JSON válido.

Ejemplos
--------

### Ejemplo: Usando `JSON.parse()`


```js
JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null
```

### Ejemplo: `Usando el parámetro reviver`

Si se especifica un reviver, el valor computado por el parsing *es transformado* antes de retornar. Específicamente, el valor computado, y todas sus propiedades (comenzando con las propiedades más anidadas y siguiendo al propio valor original), son individualmente ejecutados a través del `reviver`, el cual es llamado con el objeto que contiene la propiedad que está siendo procesada como `this` y con el nombre de la propiedad como cadena y el valor de la propiedad como argumentos. Si la función `reviver` retorna `undefined` (o no retorna algún valor, por ejemplo: si la ejecución cae el final de la función), la propiedad es eliminada del objeto. De otra manera, la propiedad es redefinidad para ser el valor de retorno.

El `reviver` es llamada último con la cadena vacía y el valor más alto para permitir la transformación del valor más alto. Asegúrese de manejar este caso adecuadamente, por lo general mediante la devolución del valor proporcionado, o `JSON.parse` will retorna `undefined`.


```js
JSON.parse('{"p": 5}', function (k, v) {
  if (k === "") return v; // if topmost value, return it,
  return v \* 2; // else return v \* 2.
}); // { p: 10 }

JSON.parse('{"1": 1, "2": 2,"3": {"4": 4, "5": {"6": 6}}}', function (k, v) {
  console.log(k); // log the current property name, the last is "".
  return v; // return the unchanged property value.
});

// 1
// 2
// 4
// 6
// 5
// 3
// ""
```

### `JSON.parse()` no admite comas finales


```js
// ambos lanzarán un SyntaxError
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{"foo" : 1, }');
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

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

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

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

* Utilizando (en-US) JSON nativo (en-US)