recursal/MDN huggingface dataset:
ReferenceError
==============

El objeto **`ReferenceError`** representa un error cuando se hace referencia a una variable inexistente.

Constructor
-----------

`ReferenceError()` (en-US)

Crea un nuevo objeto `ReferenceError`.

Propiedades de la instancia
---------------------------

`ReferenceError.prototype.message`

Mensaje de error. Aunque ECMA-262 especifica que `ReferenceError` debe proporcionar su propia propiedad `message`, en `SpiderMonkey`, hereda `Error.prototype.message`.

`ReferenceError.prototype.name`

Nombre del error. Heredado de `Error`.

`ReferenceError.prototype.fileName`

Ruta al archivo que generó este error. Heredado de `Error`.

`ReferenceError.prototype.lineNumber`

Número de línea en el archivo que generó este error. Heredado de `Error`.

`ReferenceError.prototype.columnNumber` (en-US)

Número de columna en la línea que generó este error. Heredado de `Error`.

`ReferenceError.prototype.stack` (en-US)

Seguimiento de la pila. Heredado de `Error`.

Ejemplos
--------

### Capturar un `ReferenceError`


```js
try {
  let a = undefinedVariable;
} catch (e) {
  console.log(e instanceof ReferenceError); // true
  console.log(e.message); // "undefinedVariable no está definida"
  console.log(e.name); // "ReferenceError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 6
  console.log(e.stack); // "@Scratchpad/2:2:7\n"
}
```

### Crear un `ReferenceError`


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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-referenceerror |

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

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

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

* `Error`
RangeError
==========

El objeto **`RangeError`** indica un error cuando un valor no se encuentra dentro de un rango de valores permitidos.

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

 Se lanza un `RangeError` cuando se intenta pasar un valor como argumento a una función
 que no permite un rango que incluye el valor.

Esto puede ocurrir cuando:

* pasas un valor que no es uno de los valores de cadena permitidos a `String.prototype.normalize()`, o
* cuando intentas crear una matriz de una longitud inválida con el constructor `Array`, o
* cuando pasas valores inválidos a los métodos numéricos `Number.prototype.toExponential()` (en-US),
 `Number.prototype.toFixed()` o `Number.prototype.toPrecision()`.
Constructor
-----------

`RangeError()` (en-US)

Crea un nuevo objecto `RangeError`.

Propiedades de instancia
------------------------

`RangeError.prototype.message`

Mensaje de error.

`RangeError.prototype.name`

Nombre del error. Heredado de `Error`.

`RangeError.prototype.fileName`

Ruta al archivo que generó este error. Heredado de `Error`.

`RangeError.prototype.lineNumber`

Número de línea en el archivo que generó este error. Heredado de `Error`.

`RangeError.prototype.columnNumber` (en-US)

Número de columna en la línea que generó este error. Heredado de `Error`.

`RangeError.prototype.stack` (en-US)

Seguimiento de pila. Heredado de `Error`.

Ejemplo
-------

### Usando RangeError (para valores numéricos)


```js
function check(n) {
  if (!(n >= -500 && n <= 500)) {
    throw new RangeError("El argumento debe estar entre -500 y 500.");
  }
}

try {
  check(2000);
} catch (error) {
  if (error instanceof RangeError) {
    // Manejar el error
  }
}
```

### Usando RangeError (para valores no numéricos)


```js
function check(value) {
  if (["apple", "banana", "carrot"].includes(value) === false) {
    throw new RangeError(
      'El argumento debe de ser una "apple", "banana", o "carrot".',
    );
  }
}

try {
  check("cabbage");
} catch (error) {
  if (error instanceof RangeError) {
    // Manejar el error
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-rangeerror |

Compativilidad con navegadores
------------------------------

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

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

* `Error`
* `Array`
* `Number.toExponential()` (en-US)
* `Number.toFixed()`
* `Number.toPrecision()`
* `String.prototype.normalize()`
encodeURI
=========

Sumario
-------

Codifica un Identificador de Recurso Uniforme (Uniform Resource Identifier, URI) reemplazando cada instancia de ciertos carácteres por uno, dos o tres secuencias de escape representando el carácter codificado en UTF-8.

Sintaxis
--------

`encodeURI(URI)`

### Parámetros

`URI`

Un Identificador de Recurso Uniforme codificado.

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

Se asume que el URI es un URI completo, a fin de no codificar caracteres reservados que tienen un significado especial en la URI.

`encodeURI` reemplaza todos los caracteres excepto los siguientes con las secuencias de escape UTF-8:

| Tipo | Incluye |
| --- | --- |
| Caracteres reservados | `; , / ? : @ & = + $` |
| Caracteres No escape | Alfabéticos, dígitos decimales, `- _ . ! ~ * ' ( )` |
| Almohadilla | `#` |

Tenga en cuenta que encodeURI por sí sola no puede formar solicitudes correctas HTTP GET y POST, como por XMLHTTPRequests, porque "&", "+", y "=" no están codificados, los cuales son tratados como caracteres especiales en las solicitudes GET y POST. `encodeURIComponent`, sin embargo, codifica estos caracteres. Lo más probable es que estos comportamientos no sean compatibles en los navegadores Web.

Ver También
-----------

* `decodeURI`
* `encodeURIComponent` (en-US)
* `decodeURIComponent`
URIError
========

 El objeto **`URIError`** representa un error cuando una función de manejo de URI
 global se usó de manera incorrecta.

Constructor
-----------

`URIError()` (en-US)

Crea un nuevo objeto `URIError`.

Propiedades de instancia
------------------------

`URIError.prototype.message`

Mensaje de error.

`URIError.prototype.name`

Nombre de error. Heredado de `Error`.

`URIError.prototype.fileName`

Ruta al archivo que provocó este error. Heredado de `Error`.

`URIError.prototype.lineNumber`

 Número de línea en el archivo que provocó este error. Heredado de
 `Error`.


`URIError.prototype.columnNumber` (en-US)

 Número de columna en la línea que provocó este error. Heredado de
 `Error`.


`URIError.prototype.stack` (en-US)

Rastro de pila. Heredado de `Error`.

Ejemplos
--------

### Atrapando un URIError


```js
try {
  decodeURIComponent("%");
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "malformed URI sequence"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### Creando un URIError


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

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-urierror |

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

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

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

* `Error`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()` (en-US)
parseInt()
==========

Resumen
-------

Convierte (parsea) un argumento de tipo cadena y devuelve un entero de la base especificada.

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

parseInt(string, base);
```

### Parámetros

`cadena`

Una cadena que representa el valor que se desea convertir.

`base`

Un entero que representa la base de la mencionada cadena.

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

`parseInt` es una función de alto nivel y no está asociada a ningún objeto.

La función `parseInt` comprueba el primer argumento, una cadena, e intenta devolver un entero de la base especificada. Por ejemplo, una base de 10 indica una conversión a número decimal, 8 octal, 16 hexadecimal, y así sucesivamente. Para bases superiores a 10, las letras del alfabeto indican numerales mayores que 9. Por ejemplo, para números hexadecimales (base 16), se utiliza de la A hasta la F.

Si `parseInt` encuentra un carácter que no es un numeral de la base especificada, lo ignora a él y a todos los caracteres correctos siguientes, devolviendo el valor entero obtenido hasta ese punto. `parseInt` trunca los números en valores enteros. Se permiten espacios anteriores y posteriores.

Si no se especifica la base o se especifica como 0, JavaScript asume lo siguiente:

* Si el parámetro `cadena` comienza por "0x", la base es 16 (hexadecimal).
* Si el parámetro `cadena` comienza por "0", la base es de 8 (octal). Esta característica está desaconsejada.
* Si el parámetro `cadena` comienza por cualquier otro valor, la base es 10 (decimal).

Si el primer carácter no se puede convertir en número, `parseInt` devuelve `NaN`.

Para fines aritméticos, el valor `NaN` no es un número en ninguna base. Puede llamar a la función `isNaN` para determinar se el resultado de `parseInt` es `NaN`. Si se pasa `NaN` en operaciones aritméticas, la operación resultante también será `NaN`.

Para convertir números a su literal cadena en una base en particular, utilice `intValue.toString(base)`.

Ejemplos
--------

### Ejemplo: Usando `parseInt`

Todos los siguientes ejemplos devuelven 15:


```js
parseInt("F", 16);
parseInt("17", 8);
parseInt("15", 10);
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15\*3", 10);
parseInt("12", 13);
```


Todos los siguientes ejemplos devuelven `NaN`:


```js
parseInt("Hello", 8); // No es un número en absoluto
parseInt("0x7", 10); // No es de base 10
parseInt("546", 2); // Los dígitos no son válidos para representaciones binarias.
```


Incluso aunque la base especificada es diferente, todos los siguientes ejemplos devuelven 17 ya que el argumento `cadena` comienza por "`0x`".


```js
parseInt("0x11", 16);
parseInt("0x11", 0);
parseInt("0x11");
```

### Véase También

* `parseFloat()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`
* `Number.toString()`
* `Object.valueOf`
Infinity
========

La propiedad global **`Infinity`** es un valor numérico que representa el infinito.

Pruébalo
--------

Valor
-----

El mismo valor numérico que `Number.POSITIVE_INFINITY`.

| Atributos de la propiedad `Infinity` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

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

`Infinity` es una propiedad del *objeto global*. En otras palabras, es una variable de alcance global.

El valor `Infinity` (infinito positivo) es mayor que cualquier otro número.

Este valor se comporta de forma ligeramente diferente al infinito matemático; consulte `Number.POSITIVE_INFINITY` para obtener más información.

Ejemplos
--------

### Utilizando Infinity


```js
console.log(Infinity); /\* Infinity \*/
console.log(Infinity + 1); /\* Infinity \*/
console.log(Math.pow(10, 1000)); /\* Infinity \*/
console.log(Math.log(0)); /\* -Infinity \*/
console.log(1 / Infinity); /\* 0 \*/
console.log(1 / 0); /\* Infinity \*/
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-infinity |

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

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

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

* `Number.NEGATIVE_INFINITY`
* `Number.POSITIVE_INFINITY`
* `Number.isFinite`
escape()
========

**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.

**Advertencia:** `escape()` no esta estrictamente en desuso("eliminada por los estándares Web"), esta definida en Anexo B El estándar ECMA-262 , cuya introducción establece:

> 
> … Todos las características especificas y comportamientos del lenguaje en este anexo tienen mas de una caracterísitca indeseable y en ausencia del legado sera eliminada de esta especificación. …
> 
> 
> … Los programadores no deben usar o suponer la existencia de estas características y/o comportamientos al escribir nuevo código ECMAScript …
> 
> 
> 

La función obsoleta **`escape()`** crea una nueva cadena de caracteres en los que ciertos caracteres han sido sustituidos por una secuencia hexadecimal de escape.

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

escape(str)
```

### Parametros

`str`

Cadena a codificar.

### Devuelve

Una nueva cadena en la que ciertos caracteres han sido sustituidos.

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

La función `escape` es una propiedad del *objeto global.* SLos caracteres especiales son codificados a excepción de: `@*_+-./`

La forma hexadecimal de los caracteres cuyo valor es 0xFF o menor, es una secuencia de escape de dos digitos: %xx. Para caracteres un valor superior, se usa el fomato de cuatro digitos: %**u**xxxx.

Ejemplos
--------


```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// caracteres especiales
escape("@\*\_+-./"); // "@\*\_+-./"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

Ver más
-------

* `encodeURI`
* `encodeURIComponent` (en-US)
* `unescape`
Symbol.isConcatSpreadable
=========================

El símbolo conocido como **`Symbol.isConcatSpreadable`** se utiliza para configurar si un objeto debe ser aplanado a sus elementos del array cuando se utiliza el método `Array.prototype.concat()`.

Pruébalo
--------

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

El símbolo `@@isConcatSpreadable` (`Symbol.isConcatSpreadable`) puede ser definido como una propiedad propia o heredada y su valor es un booleano. Puede controlar el comportamiento de los arrays y de los objetos tipo array:

* Para los objetos tipo matriz, el comportamiento por defecto es extender (aplanar) los elementos. `Symbol.isConcatSpreadable` puede evitar el aplanamiento en estos casos.
* En el caso de los objetos tipo array, el comportamiento por defecto es no extender ni aplanar. `Symbol.isConcatSpreadable` puede forzar el aplanamiento en estos casos.

| Atributos de la propiedad `Symbol.isConcatSpreadable` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Ejemplos
--------

### Arrays

Por defecto, `Array.prototype.concat()` extiende (aplana) las matrices en su resultado:


```js
let alpha = ['a', 'b', 'c'],
let numeric = [1, 2, 3]

let alphaNumeric = alpha.concat(numeric)

console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', 1, 2, 3]
```


Al establecer el valor de `Symbol.isConcatSpreadable` a `false`, puedes desactivar el comportamiento por defecto:


```js
let alpha = ["a", "b", "c"];
let numeric = [1, 2, 3];

numeric[Symbol.isConcatSpreadable] = false;
let alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // Resultado: ['a', 'b', 'c', [1, 2, 3] ]
```

### Objetos tipo array

Para los objetos tipo array, el valor por defecto es no extender. `Symbol.isConcatSpreadable` necesita ser establecido a `true` para obtener un array aplanado:


```js
let x = [1, 2, 3];

let fakeArray = {
  [Symbol.isConcatSpreadable]: true,
  length: 2,
  0: "hello",
  1: "world",
};

x.concat(fakeArray); // [1, 2, 3, "hello", "world"]
```


**Nota:** La propiedad `length` se utiliza para controlar el número de propiedades del objeto a añadir. En el ejemplo anterior, `length:2` indica que hay que añadir dos propiedades.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.isconcatspreadable |

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

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

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

* Polyfill de `Symbol.isConcatSpreadable` en `core-js`
* `Array.prototype.concat()`
Symbol.prototype.description
============================

La propiedad **`description`** de sólo lectura es una cadena que devuelve la descripción opcional de los objetos `Symbol`.

Pruébalo
--------

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

Los objetos `Symbol` pueden ser creados con una descripción opcional que puede ser usada para depuración pero no para acceder al símbolo en sí. La propiedad `Symbol.prototype.description` puede utilizarse para leer esa descripción. Es diferente a `Symbol.prototype.toString()` ya que no contiene la cadena "`Symbol()`" que la rodea. Vea los ejemplos.

Ejemplos
--------

### Uso de description


```js
Symbol("desc").toString(); // "Symbol(desc)"
Symbol("desc").description; // "desc"
Symbol("").description; // ""
Symbol().description; // undefined

// well-known symbols
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)"
Symbol.iterator.description; // "Symbol.iterator"

// global symbols
Symbol.for("foo").toString(); // "Symbol(foo)"
Symbol.for("foo").description; // "foo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.description |

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

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

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

* Polyfill de `Symbol.prototype.description` en `core-js`
* `Symbol.prototype.toString()`
* Polyfill: https://npmjs.com/symbol.prototype.description
Symbol.species
==============

El símbolo conocido como **`Symbol.species`** especifica una propiedad con valor de función que la función constructora utiliza para crear objetos derivados.

Pruébalo
--------

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

La propiedad de acceso `species` permite a las subclases anular el constructor por defecto de los objetos.

| Atributos de la propiedad `Symbol.species` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Ejemplos
--------

### Usando species

Es posible que quieras devolver objetos `Array` en tu clase array derivada `MyArray`. Por ejemplo, al utilizar métodos como `map()` que devuelven el constructor por defecto, quieres que estos métodos devuelvan un objeto `Array` padre, en lugar del objeto `MyArray`. El símbolo `species` te permite hacer esto:


```js
class MyArray extends Array {
  // Sobrescribir especies al constructor de la matriz Array
  static get [Symbol.species]() {
    return Array;
  }
}
let a = new MyArray(1, 2, 3);
let mapped = a.map((x) => x \* x);

console.log(mapped instanceof MyArray); // false
console.log(mapped instanceof Array); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.species |

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

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

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

* `Map[@@species]` (en-US)
* `Set[@@species]` (en-US)
Symbol.split
============

El símbolo conocido como **`Symbol.split`** especifica el método que divide una cadena en los índices que coinciden con una expresión regular. Esta función es llamada por el método `String.prototype.split()`.

Para más información, véase `RegExp.prototype[@@split]()` (en-US) y `String.prototype.split()`.

Pruébalo
--------

| Atributos de la propiedad `Symbol.split` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Ejemplos
--------

### División inversa personalizada


```js
class ReverseSplit {
  [Symbol.split](string) {
    const array = string.split(" ");
    return array.reverse();
  }
}

console.log("Another one bites the dust".split(new ReverseSplit()));
// resultado esperado: [ "dust", "the", "bites", "one", "Another" ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.split |

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

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

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

* Polyfill de `Symbol.split` en `core-js`
* `Symbol.match`
* `Symbol.replace`
* `Symbol.search`
* `RegExp.prototype[@@split]()` (en-US)
Symbol.unscopables
==================

El símbolo conocido como **`Symbol.unscopables`** se utiliza para especificar un valor de objeto cuyos nombres de propiedades propias y heredadas se excluyen de los enlaces de entorno `with` (en-US) del objeto asociado.

Pruébalo
--------

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

El símbolo `@@unscopables` (`Symbol.unscopables`) puede definirse en cualquier objeto para excluir los nombres de propiedades de ser expuestos como variables léxicas en los enlaces de entorno `with` (en-US). Tenga en cuenta que si utiliza Modo estricto, las declaraciones `with` no están disponibles y probablemente tampoco necesiten este símbolo.

Establecer una propiedad a `true` en un objeto `unscopable` la hará *unscopable* y por tanto no aparecerá en las variables de ámbito léxico. Establecer una propiedad a `false` la hará `scopable` y por lo tanto aparecerá en las variables de ámbito léxico.

| Atributos de la propiedad `Symbol.unscopables` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Ejemplos
--------

### Scoping con sentencias

El siguiente código funciona bien en ES5 y posteriores. Sin embargo, en ECMAScript 2015 y posteriores, se introdujo el método `Array.prototype.keys()`. Eso significa que dentro del entorno `with` "keys" sería ahora el método y no la variable. Fue entonces cuando se introdujo el símbolo `unscopable`. Un ajuste incorporado de `unscopables` se implementa como `Array.prototype[@@unscopables]` para evitar que algunos de los métodos de Array se encuentren dentro de la declaración `with`.


```js
const keys = [];

with (Array.prototype) {
  keys.push("something");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

### Unscopables en objetos

También puede establecer `unscopables` para sus propios objetos.


```js
const obj = {
  foo: 1,
  bar: 2,
};

obj[Symbol.unscopables] = {
  foo: false,
  bar: true,
};

with (obj) {
  console.log(foo); // 1
  console.log(bar); // ReferenceError: bar is not defined
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.unscopables |

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

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

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

* `Array.prototype[@@unscopables]`
* Sentencia `with` (en-US) (no disponible en Strict mode)