recursal/MDN huggingface dataset:
TypeError
=========

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

Un `TypeError` puede ser lanzado cuando:

* Un operando o argumento pasado a una función es incompatible con el tipo esperado por el operador o función.
* Cuando se intenta modificar un valor que no puede ser alterado.
* Cuando se intenta usar un valor de una forma inapropiada.
Constructor
-----------

`TypeError()`

Crea un nuevo objeto `TypeError`.

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

`TypeError.prototype.message`

Mensaje del error.

`TypeError.prototype.name`

Nombre del error. Heredado de `Error`.

`TypeError.prototype.cause`

Causa del error. Heredado de `Error`.

`TypeError.prototype.fileName` 
Non-standard

Ruta al archivo que ha lanzado este error. Heredado de `Error`.

`TypeError.prototype.lineNumber` 
Non-standard

Numero de línea donde se ha lanzado este error. Heredado de `Error`.

`TypeError.prototype.columnNumber` (en-US) 
Non-standard

Numero de columna donde se ha lanzado este error. Heredado de `Error`.

`TypeError.prototype.stack` (en-US) 
Non-standard

Seguimiento de pila. Heredado de `Error`.

Ejemplos
--------

### Capturar 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-native-error-types-used-in-this-standard-typeerror |

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

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

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

* `Error`
unescape()
==========

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

**Nota:** `unescape()` no es una función estándar implementada por los navegadores y solo se estandarizó para la compatibilidad entre motores. No es necesario que todos los motores de JavaScript lo implementen y es posible que no funcione en todas partes. Use `decodeURIComponent()` o `decodeURI()` si es posible.

La función **`unescape()`** calcula una nueva cadena en la que las secuencias de escape hexadecimales se reemplazan con los caracteres que representan. Las secuencias de escape pueden ser introducidas por una función como `escape()`.

Sintaxis
--------


```js
unescape(str)
```

### Parámetros

`str`

Una cadena a decodificar.

### Valor de retorno

Una nueva cadena en la que ciertos caracteres no han sido reemplazados.

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

`unescape()` es una propiedad de función del objeto global.

La función `unescape()` reemplaza cualquier secuencia de escape con el carácter que representa. Específicamente, reemplaza cualquier secuencia de escape de la forma `%XX` o `%uXXXX` (donde `X` representa un dígito hexadecimal) con el carácter que tiene el valor hexadecimal `XX`/`XXXX`. Si la secuencia de escape no es una secuencia de escape válida (por ejemplo, si "%" va seguido de uno o ningún dígito hexadecimal), se deja como está.

**Nota:** Esta función se usó principalmente para la codificación de URL y se basa en parte en el formato de escape en RFC 1738. La función `unescape()` *no* evalúa secuencias de escape en cadenas literales. Puede reemplazar `\xXX` con `%XX` y `\uXXXX` con `%uXXXX` para obtener una cadena que `unescape()` pueda manejar.

Ejemplos
--------

### Utilizando unescape()


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

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

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

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

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

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

* Polyfill de `unescape` en `core-js`
* `decodeURI`
* `decodeURIComponent`
* `escape`
parseFloat()
============

La función **`parseFloat()`** analiza un argumento (si es necesario, lo convierte en una cadena) y devuelve un número de coma flotante.

Pruébalo
--------

Sintaxis
--------


```js
parseFloat(string);
```

### Parámetros

`string`

 La cadena que representa al valor que se desea convertir.
 Si este argumento no es una cadena, entonces, será convertida en una usando
 la operación abstracta `ToString`.
 Se ignora el espacio en blanco inicial en este argumento.


### Valor de retorno

Un número de coma flotante analizado a partir de la `cadena` dada.

 O `NaN` cuando el primer carácter que no es un espacio en blanco
 no se puede convertir en un número.

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

`parseFloat` es una propiedad de función del objeto global.

* Si `parseFloat` encuentra un carácter que no sea un signo más (`+`),
 signo menos (`-` U+002D HYPHEN-MINUS), numeral (`0` - `9`), punto decimal (`.`)
 o exponente (`e` o `E`), devuelve el valor hasta ese carácter,
 ignorando el carácter inválido y los caracteres que le siguen.
* Un *segundo* decimal también detiene el análisis (caracteres hasta ese punto se seguirá analizando).
* Se ignoran los espacios iniciales y finales en el argumento.
* Si el primer carácter del argumento no se puede convertir en un número (no es
 ninguno de los caracteres anteriores), `parseFloat` devuelve `NaN`
* `parseFloat` también puede analizar y devolver `Infinity`.
* `parseFloat` convierte la sintasis `BigInt` (en-US) a `Numbers`,
 perdiendo precisión. Esto sucede por que se descarta el carácter `n` final.

 Considera `Number(value)` para un análisis más estricto,
 que se convierte en `NaN` para argumentos con caracteres no válidos
 en cualquier lugar.

Ejemplos
--------

### `parseFloat` devolviendo un número

Todos los siguientes ejemplos devuelven `3.14`:


```js
parseFloat(3.14);
parseFloat("3.14");
parseFloat(" 3.14 ");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14some non-digit characters");
parseFloat({
  toString: function () {
    return "3.14";
  },
});
```

### `parseFloat` devolviendo `NaN`

El siguiente ejemplo devuelve `NaN`:


```js
parseFloat("FF2");
```

### `parseFloat` y `BigInt`

 Los siguientes ejemplos devuelven `900719925474099300`, perdiendo precisión como
 el entero es demasiado grande para ser representado como un decimal:


```js
parseFloat(900719925474099267n);
parseFloat("900719925474099267n");
```

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

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

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

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

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

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `Number.toFixed()`
* `isNaN()`
SyntaxError
===========

El objeto **`SyntaxError`** represta un error cuando se trata de interpretar código que resulta ser inválido sintácticamente. Esto ocurre cuando el motor de JavaScript encuentra el orden de los tokens o los token mismos no son conformes a la sinstaxis del lenguaje cuando se analiza el código.

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

`SyntaxError()` (en-US)

Crea un nuevo objeto `SyntaxError`.

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

`SyntaxError.prototype.message`

Mensaje de error. Heredado de `Error`.

`SyntaxError.prototype.fileName`

Ruta al archivo que ha provocado este error. Heredado de `Error`.

`SyntaxError.prototype.lineNumber`

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

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

Número de columna en el archivo que ha provocado este error. Heredado de `Error`.

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

Trazado de la pila de ejecución. Heredado de `Error`.

Ejemplos
--------

### Controlando un SyntaxError


```js
try {
  eval("hoo bar");
} catch (e) {
  console.error(e instanceof SyntaxError);
  console.error(e.message);
  console.error(e.name);
  console.error(e.fileName);
  console.error(e.lineNumber);
  console.error(e.columnNumber);
  console.error(e.stack);
}
```

### Creando un SyntaxError


```js
try {
  throw new SyntaxError("Hello", "someFile.js", 10);
} catch (e) {
  console.error(e instanceof SyntaxError); // true
  console.error(e.message); // Hello
  console.error(e.name); // SyntaxError
  console.error(e.fileName); // Ejemplo.js
  console.error(e.lineNumber); // 10
  console.error(e.columnNumber); // 0
  console.error(e.stack); // @debugger eval code:3:9
}
```

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

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

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

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

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

* `Error`
Reflect
=======

**Reflect** es un objecto incorporado que proporciona metodos para interceptar operaciones de javascript. Los métodos son los mismos que los de proxy handlers. `Reflect` no es un objeto de funciones y por lo tanto no puede ser construido.

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

A diferencia de la mayoria de los objetos globales, `Reflect` no es un constructor. No puede ser instanciado con un operador `new` o invocando el objecto `Reflect` como una función. Todas las propiedades y métodos de `Reflect` son estáticos (igual que los del objeto `Math`).

Métodos
-------

El objeto `Reflect` proporciona las siguientes funciones estáticas con los mismos nombres de los métodos de proxy handler. Algunos de estos métodos son correspondientes a los métodos de `Object`.

`Reflect.apply()` (en-US)

Calls a target function with arguments as specified by the `args` parameter. See also `Function.prototype.apply()`.

`Reflect.construct()` (en-US)

The `new` operator as a function. Equivalent to calling `new target(...args)`.

`Reflect.defineProperty()` (en-US)

Similar to `Object.defineProperty()`. Returns a `Boolean`.

`Reflect.deleteProperty()` (en-US)

The `delete` operator as a function. Equivalent to calling `delete target[name]`.

`Reflect.get()` (en-US)

A function that returns the value of properties.

`Reflect.getOwnPropertyDescriptor()` (en-US)

Similar to `Object.getOwnPropertyDescriptor()`. Returns a property descriptor of the given property if it exists on the object, `undefined` otherwise.

`Reflect.getPrototypeOf()` (en-US)

Same as `Object.getPrototypeOf()`.

`Reflect.has()` (en-US)

The `in` operator as function. Returns a boolean indicating whether an own or inherited property exists.

`Reflect.isExtensible()` (en-US)

Same as `Object.isExtensible()`.

`Reflect.ownKeys()` (en-US)

Returns an array of the target object's own (not inherited) property keys.

`Reflect.preventExtensions()` (en-US)

Similar to `Object.preventExtensions()`. Returns a `Boolean`.

`Reflect.set()`

A function that assigns values to properties. Returns a `Boolean` that is `true` if the update was successful.

`Reflect.setPrototypeOf()` (en-US)

A function that sets the prototype of an object.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect-object |

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

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

También ver
-----------

* The `Proxy` global object.
* The `handler` object.
decodeURIComponent
==================

Sumario
-------

Decodifica un Identificador de Recurso Uniforme (Uniform Resource Identifier, URI) previamente creado por `encodeURIComponent` (en-US) o por una rutina similar.

Sintaxis
--------

`decodeURIComponent(encodedURI)`

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

`encodedURI`

Un Identificador de Recurso Uniforme codificado.

Valor retornado
---------------

Retorna una nueva cadena representando la version decodificada del componente URI dado

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

Sustituye a cada secuencia de escape codificado en URI con el carácter que representa.

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

* `decodeURI`
* `encodeURI`
* `encodeURIComponent` (en-US)
NaN
===

La propiedad global `NaN` es un valor que representa Not-A-Number.

Sumario
-------

Un valor representando un Not-A-Number (No es Un Número).

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

Sintaxis
--------

`NaN`

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

`NaN` es una propiedad del *global object (objeto global)*, por ejemplo, es una variable de alcance global.

El valor inicial de `NaN` es Not-A-Number (No es Un Número) - lo mismo que el valor de `Number.NaN`.

Keep text below in sync with Number.NaN page `NaN` nunca es equivalente con cualquier otro número, incluido el mismo `NaN`; no puedes chequear el valor de un not-a-number comparándolo con `Number.NaN`. Usar la función `isNaN()` para aquello.

Muchos métodos de JavaScript (como son el `Number` constructor, `parseFloat` y `parseInt`) retornan `NaN` si el valor especificado en el parámetro no puede ser parseado como un número.

Puedes utilizar la propiedad `NaN` para indicar una condición de error para tu función que devuelva un número en caso de éxito.

JavaScript imprime el valor `Number.NaN` como `NaN`.

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

* `Number.NaN`
* `Number.isNaN()`
* `isNaN()`
isNaN
=====

La función **`isNaN()`** determina cuando el valor es `NaN` o no. Tenga presente que la coerción dentro de la función `isNaN` tiene reglas interesantes; tal vez quieras usar de forma alternativa **`Number.isNaN()`**, como fue definido en ECMAScript 2015.

Pruébalo
--------

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

isNaN(valor)
```

### Parámetros

**`valor`**

El valor a probar o evaluar.

### Valor de retorno

**`true`** si es valor dado es `NaN`, de otro modo, **`false`**.

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

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

`isNaN` intenta convertir el parámetro pasado a un número. Si el parámetro no se puede convertir, devuelve true; en caso contrario, devuelve false.

Esta función es útil ya que el valor `NaN` no puede se probado correctamente con operadores de igualdad. `x == NaN` y `x === NaN` son siempre false, sin importar lo que sea `x`, incluso si `x` es `NaN`. Por ejemplo, tanto `1 == NaN` como `NaN == NaN` devuelven `false`.

### Ejemplos


```js
isNaN(NaN); //devuelve true
isNaN("string"); //devuelve true
isNaN("12"); //devuelve false
isNaN(12); //devuelve false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-isnan-number |

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

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

### Vea También

* `NaN`
* `Number.isNaN()`
InternalError
=============

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

El objeto **`InternalError`** indica un error que se produjo internamente en el motor JavaScript.

Los principalmente casos de ejemplo son cuando algo es demasiado grande, por ejemplo:

* "demasiados casos del switch",
* "demasiados paréntesis en la expresión regular",
* "iniciador de arreglo demasiado grande",
* "demasiada recursividad".
Constructor
-----------

`InternalError()`

Crea un nuevo objeto `InternalError`.

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

`InternalError.prototype.message`

Mensaje de error. Heredado de `Error`.

`InternalError.prototype.name`

Nombre del error. Heredado de `Error`.

`InternalError.prototype.fileName`

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

`InternalError.prototype.lineNumber`

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

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

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

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

Seguimiento de la pila. Heredado de `Error`.

Ejemplos
--------

### Demasiada recursividad

Esta función recursiva se ejecuta 10 veces, según la condición de salida.


```js
function loop(x) {
  if (x >= 10)
    // "x >= 10" es la condición de salida
    return;
  // hacer cosas
  loop(x + 1); // la llamada recursiva
}
loop(0);
```


Establecer esta condición en un valor extremadamente alto, no funcionará:


```js
function loop(x) {
  if (x >= 1000000000000) return;
  // hacer cosas
  loop(x + 1);
}
loop(0);

// InternalError: demasiada recursividad
```


Para obtener más información, consulta `InternalError: demasiada recursividad.`

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

No forma parte de ningún estándar.

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

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

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

* `Error`
* `demasiada recursividad`
EvalError
=========

El objeto **`EvalError`** indica un error relacionado con la función global `eval()`. Esta excepción ya no es lanzada por JavaScript, sin embargo el objeto `EvalError` permanece por compatibilidad.

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

`EvalError()`

Crea un nuevo objeto `EvalError`.

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

`EvalError.prototype.message`

Mensaje de error.

`EvalError.prototype.name`

Nombre del error. Heredado de `Error`.

`EvalError.prototype.fileName`

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

`EvalError.prototype.lineNumber`

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

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

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

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

Seguimiento de pila. Heredado de `Error`.

Ejemplos
--------

El objeto `EvalError` no se utiliza en la especificación actual de ECMAScript y por lo tanto no será lanzado en tiempo de ejecución. Sin embargo, el objeto en sí se mantiene para la compatibilidad con versiones anteriores de la especificación.

### Creación de un EvalError


```js
try {
  throw new EvalError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "EvalError"
  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-evalerror |

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

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

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

* `Error`
* `eval()`
decodeURI()
===========

Sumario
-------

Decodifica un Identificador de Recurso Uniforme (Uniform Resource Identifier, URI) previamente creado por `encodeURI` o por una rutina similar.

Sintaxis
--------

`decodeURI(encodedURI)`

### Parámetros

`encodedURI`

Un completo, Identificador de Recurso Uniforme.

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

Sustituye a cada secuencia de escape codificado en URI con el carácter que representa.

No decodifica secuencias de escape que no se puedan haber introducido por `encodeURI`.

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

* `decodeURIComponent`
* `encodeURI`
* `encodeURIComponent` (en-US)
ArrayBuffer
===========

El objeto **`ArrayBuffer`** se usa para representar un buffer genérico, de datos binarios brutos con una longitud específica.

Es un arreglo de bytes, frecuentemente llamado de esta forma en otros lenguajes de programación. No se puede manipular directamente el contenido de un `ArrayBuffer`; en su lugar, se crea uno de los objetos de arreglos tipados o un objeto `DataView` (en-US) que representa el buffer en un formato específico, y se usa para leer y escribir el contenido del buffer.

El constructor `ArrayBuffer` (en-US) crea un nuevo `ArrayBuffer` de la longitud especificada en bytes. También se puede obtener un `ArrayBuffer` desde datos existentes, por ejemplo, desde una cadena de caracteres en Base64 o desde un archivo local.

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

`ArrayBuffer()` (en-US)

Crea un nuevo objeto `ArrayBuffer`.

Propiedades estáticas
---------------------

`get ArrayBuffer[@@species]`

La función constructora que se usa para crear objetos derivados.

Métodos estáticos
-----------------

`ArrayBuffer.isView(arg)` (en-US)

Devuelve `true` si `arg` es una de las vistas de `ArrayBuffer`, como objetos de arreglo tipados o un `DataView` (en-US). Devuelve `false` en caso contrario.

Propiedades de instancias
-------------------------

`ArrayBuffer.prototype.byteLength`

Propiedad de solo lectura con la longitud en bytes del `ArrayBuffer`. Se establece cuando el arreglo es construido y no puede ser cambiada.

Métodos de instancias
---------------------

`ArrayBuffer.prototype.slice()` (en-US)

Devuelve un nuevo `ArrayBuffer` que contiene una copia de los bytes de este `ArrayBuffer` desde el comienzo (inclusivo) `begin` hasta el fin (exclusivo) `end`. Si `begin` o `end` son negativos, esto se refiere a un índice desde el final del arreglo, en lugar del comienzo.

Ejemplos
--------

### Creando un `ArrayBuffer`

En este ejemplo, se crea un buffer de 8 bytes con una vista `Int32Array` (en-US) consultando el buffer.


```js
const buffer = new ArrayBuffer(8);
const view = new Int32Array(buffer);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-objects |

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

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

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

* Un polyfill de `ArrayBuffer` está disponible en `core-js`
* Arraglos tipados en JavaScript
* `SharedArrayBuffer` (en-US)
* RangeError: longitud de array invalida