recursal/MDN huggingface dataset:
Number.isNaN()
==============

El método **`Number.isNaN()`** determina si el valor pasado es `NaN`. Versión más robusta de la función global `isNaN()`.

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

Number.isNaN(value)
```

### Parámetros

`valor`

El valor para ser evaluado por `NaN`.

Description
-----------

Debido a los dos operadores de igualdad, `==` (en-US) y `===` (en-US), evaluando a `false` cuando al comprobar si `NaN` *is* `NaN`, la función `Number.isNaN()` se ha convertido en necesaria. Esta situación es diferente a las otras comparaciones de valor en JavaScript.

En comparación a la función global `isNaN()`, `Number.isNaN()` no sufre el problema de forzar la conversión del parámetro a un número. Esto significa que ahora es seguro pasar valores que normalmente se convertirían a `NaN`, pero no son del mismo valor que `NaN`. Esto también significa que solo los valores de tipo número, que también son `NaN`, retornan `true`.

Examples
--------


```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true

// e.g. estos hubiesen sido true con la función global isNaN()
Number.isNaN("NaN"); // false
Number.isNaN(undefined); // false
Number.isNaN({}); // false
Number.isNaN("blabla"); // false

// Todos retornan false
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
```

Polyfill
--------


```js
Number.isNaN =
  Number.isNaN ||
  function (value) {
    return typeof value === "number" && isNaN(value);
  };

// O
Number.isNaN =
  Number.isNaN ||
  function (value) {
    return value !== value;
  };
```

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

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

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

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

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

* `Number`
* `isNaN()`
Number.prototype.valueOf()
==========================

El método **`valueOf()`** retorna el valor primitivo inserto en un objeto `Number`.

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

numObj.valueOf()
```

### Valor retornado

Un número representando al valor primitivo del objeto `Number` especificado.

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

Este método es usualmente llamado de forma interna por JavaScript y no es explicitado en el código web.

Ejemplos
--------

### Utilizando `valueOf`


```js
var numObj = new Number(10);
console.log(typeof numObj); // objeto

var num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // número
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.valueof |

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

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

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

* `Number.prototype.toSource()` (en-US)
Number.prototype.toString()
===========================

Resumen
-------

Devuelve una cadena que representa al objeto *Number* especificado

Sintaxis
--------

`number .toString( [base ] )`

### Parámetro

base

Un entero entre 2 y 36 especificando la base a usar para representar los valores numéricos.

### Devuelve

Una cadena que representa al objeto.

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

El objeto `Number` sobreescribe el método `toString` y no lo hereda del objeto `Object`; por tanto no hereda `Object.prototype.toString()`. Para objetos `Number`, el método `toString` devuelve una cadena que representa al objeto en la base especificada.

El método toString comprueba su primer argumento, e intenta devolver una cadena de representación en la base especificada. Para bases superiores a 10, las letras del alfabeto indican numerales mayores de 9. Por ejemplo, para números hexadecimales (base 16), se utiliza de A hasta F.

Si no se da a toString una base entre 2 y 36, se lanza una excepción.

Si no se especifica la base, JavaScript asume la base predefinida, que es 10.

Ejemplos
--------


```js
var howMany = 10;

alert("howMany.toString() is " + howMany.toString()); // displays "10"

alert("45 .toString() is " + (45).toString()); //displays "45"

var x = 7;
alert(x.toString(2)); // Displays "111"
```

Vea También
-----------

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()` (en-US)
* `Number.prototype.toPrecision()`
Number.prototype.toFixed()
==========================

El método **`toFixed()`** formatea un número usando notación de punto fijo.

Pruébalo
--------

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

numObj.toFixed([digitos])
```

### Parametros

`digitos`

Opcional. El número de digitos que aparecen después del punto decimal; este puede ser un valor entre 0 y 20, inclusive, algunas implementaciones pueden soportar un rango más amplio de valores. Si el argumento es omitido, es tratado como 0.

### Valor Devuelto

Una cadena que representa el número dado, usando notación de punto fijo.

### Excepciones

`RangeError`

Si `digits` es demasiado pequeño o demasiado grande. Los valores entre 0 y 20, inclusive, no causarán un error tipo ``RangeError``. Las implementaciones también pueden admitir valores cada vez más grandes.

`TypeError`

Si este método se invoca en un objeto que no es un `Number`.

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

**`toFixed()`** devuelve una representación de cadena de `numObj` que no usa notación exponencial y tiene exactamente `dígitos` dígitos después del decimal. El número se redondea si es necesario, y la parte fraccional se rellena con ceros si es necesario para que tenga la longitud especificada.Si `numObj` es mayor que `1e+21`, este metodo llama a `Number.prototype.toString()` y retorna una cadena de notacion exponencial.

Examples
--------

### Using `toFixed`


```js
var numObj = 12345.6789;

numObj.toFixed(); // Returns '12346': note rounding, no fractional part
numObj.toFixed(1); // Returns '12345.7': note rounding
numObj.toFixed(6); // Returns '12345.678900': note added zeros
(1.23e20).toFixed(2); // Returns '123000000000000000000.00'
(1.23e-10).toFixed(2); // Returns '0.00'
(2.34).toFixed(1); // Returns '2.3'
(2.35).toFixed(1); // Returns '2.4'. Note that it rounds up in this case.
-(2.34).toFixed(1); // Returns -2.3 (due to operator precedence, negative number literals don't return a string...)
(-2.34).toFixed(1); // Returns '-2.3' (...unless you use parentheses)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.tofixed |

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

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

See also
--------

* `Number.prototype.toExponential()` (en-US)
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`
Number.parseInt()
=================

El método estático **`Number.parseInt()`** analiza un argumento de cadena y devuelve un número entero de la raíz o base especificada.

Pruébalo
--------

Sintaxis
--------


```js
Number.parseInt(string)
Number.parseInt(string, radix)
```

### Parámetros

`string`

El valor a analizar, forzado a una cadena. Se ignoran los espacios en blanco iniciales en este argumento.

`radix` Opcional

Un número entero entre `2` y `36` que representa la *base* (la base en los sistemas numéricos matemáticos) del `string`.

Si `radix` no está definida o es `0`, se supone que es `10`, excepto cuando el número comienza con los pares de unidades de código `0x` o `0X`, en cuyo caso se asume una base de `16`.

### Valor devuelto

Un entero analizado a partir del `string` dado.

Si `radix` es menor que `2` o mayor que `36`, o el primer carácter que no es un espacio en blanco no se puede convertir en un número, se devuelve `NaN`.

Ejemplos
--------

### Number.parseInt vs. parseInt

Este método tiene la misma funcionalidad que la función global `parseInt()`:


```js
Number.parseInt === parseInt; // true
```


Su propósito es la modularización de globales. Consulte `parseInt()` para obtener más detalles y ejemplos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parseint |

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

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

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

* Polyfill de `Number.parseInt` en `core-js`
* El objeto `Number` al que pertenece.
* El método global `parseInt()`.
Number.MIN\_VALUE
=================

La propiedad **`Number.MIN_VALUE`** representa el menor valor positivo numérico representable en JavaScript.

| Atributos de la propiedad `Number.MIN_VALUE` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

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

La propiedad `MIN_VALUE` es el número más cercano a 0, no el más negativo, que JavaScript puede representar.

`MIN_VALUE` tiene un valor aproximado de `5e-324`. Los valores menores que `MIN_VALUE` ("subdesbordamiento de valores") son convertidos a 0.

Ya que `MIN_VALUE` es una propiedad estática de `Number`, debes utilizarla como `Number.MIN_VALUE`, más que como una propiedad del objeto `Number` que has creado.

Ejemplos
--------

### Usando `MIN_VALUE`

El siguiente código divide dos valores numéricos. Si el resultado es mayor o igual a `MIN_VALUE`, se ejecuta la función `func1`, si no, se ejecuta la función `func2`.


```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_value |

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

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

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

* `Number.MAX_VALUE`
Number.NaN
==========

La propiedad **`Number.NaN`** representa Not-A-Number (No es numero). Equivalente de `NaN`.

Pruébalo
--------

No tienes que crear un objeto `Number` para acceder a esta propiedad estática (usa `Number.NaN`).

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

Ejemplos
--------

### Chequea si los valores son numericos


```js
function sanitise(x) {
  if (isNaN(x)) {
    return Number.NaN;
  }
  return x;
}
```

### Testing against NaN

See Testing against NaN on the `NaN` page.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

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

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

Tambien mira
------------

* El objeto global `NaN` .
* El objeto `Number` al que pertenece.
Number.prototype.toPrecision()
==============================

El método **`toPrecision()`** devuelve una cadena que representa un objeto `Number` según la precisión especificada.

Pruébalo
--------

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

numObj.toPrecision([precision])
```

### Parámetros

`precision`

Opcional. Un entero que especifica el número de digitos significativos.

### Valor devuelto

Una cadena que representa un objeto `Number` en punto fijo o en notación exponencial redondeada a `precision` de digitos significativos. Vea la discusión acerca del redondeo en la descripción del método `Number.prototype.toFixed()` , que además aplica a `toPrecision()`.

Si el parámetro `precision` es omitido, se comporta como `Number.prototype.toString()`. Si el parámetro `precision` es un valor no entero, el valor es redondeado al entero más cercano.

### Exceptions

`RangeError`

If `precision` is not between 1 and 100 (inclusive), a `RangeError` is thrown. Implementations are allowed to support larger and smaller values as well. ECMA-262 only requires a precision of up to 21 significant digits.

Ejemplos
--------

### Usando `toPrecision`


```js
var numObj = 5.123456;

console.log(numObj.toPrecision()); // logs '5.123456'
console.log(numObj.toPrecision(5)); // logs '5.1235'
console.log(numObj.toPrecision(2)); // logs '5.1'
console.log(numObj.toPrecision(1)); // logs '5'

numObj = 0.000123;

console.log(numObj.toPrecision()); // logs '0.000123'
console.log(numObj.toPrecision(5)); // logs '0.00012300'
console.log(numObj.toPrecision(2)); // logs '0.00012'
console.log(numObj.toPrecision(1)); // logs '0.0001'

// observe que bajo algunas circunstancias el valor retornado es en notación exponencial
console.log((1234.5).toPrecision(2)); // logs '1.2e+3'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toprecision |

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

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

Vea También
-----------

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()` (en-US)
* `Number.prototype.toString()`
Number.parseFloat()
===================

El método **`Number.parseFloat()`** analiza un argumento y devuelve un número de punto flotante. Si un número no se puede analizar a partir del argumento, devuelve `NaN`.

Pruébalo
--------

Sintaxis
--------


```js
Number.parseFloat(string);
```

### Parámetros

`string`

El valor a analizar. Si este argumento no es una cadena, entonces se convierte 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 convertido a partir del `string` dado.

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

Ejemplos
--------

### Number.parseFloat vs parseFloat

Este método tiene la misma funcionalidad que la función global `parseFloat()`:


```js
Number.parseFloat === parseFloat; // true
```


Este método también es parte de ECMAScript 2015. (Su propósito es la modularización de globales).

Consulte `parseFloat()` para obtener más detalles y ejemplos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

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

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

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

* Polyfill de `Number.parseFloat` en `core-js`
* `Number`: El objeto al que pertenece este método.
* El método global `parseFloat()`.
Constructor Error()
===================

El constructor **`Error`** crea un objeto `Error`.

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

new Error([message[, fileName[, lineNumber]]])
```

### Parámetros

`message`Opcional

Una descripción del error legible para los humanos.

`fileName` Opcional
Non-standard

El valor de la propiedad `fileName` en el objeto `Error` creado. De manera predeterminada, el nombre del archivo que contiene el código que llamó al constructor `Error()`.

`lineNumber` Opcional
Non-standard

El valor de la propiedad `lineNumber` en el objeto `Error` creado. De manera predeterminada, el número de línea que contiene la invocación del constructor `Error()`.

Ejemplos
--------

### Llamada a función o construcción `new`

Cuando se usa `Error` como una función, sin `new`, devolverá un objeto `Error`. Por lo tanto, una simple llamada a `Error` producirá el mismo resultado que la construcción de un objeto `Error` mediante la palabra clave `new`.


```js
// esto...
const x = Error("¡Fui creado usando una llamada a función!");

// ...tiene la misma funcionalidad que esta.
const y = new Error('¡Fui construido con la palabra clave "new"!');
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-error-constructor |

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

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

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

* `throw`
* `try...catch`
Error.prototype.lineNumber
==========================

No es una norma

Esta característica no es una norma y no está en la lista de normas. No la utilice en sitios de producción que enfrenta la Web: no va a funcionar para todos los usuarios. También puede haber grandes incompatibilidades entre implementaciones y el comportamiento puede cambiar en el futuro.

La propiedad **lineNumber** contiene el número de linea en el archivo que arrojó el error.

Ejemplos
--------

### Utilizando `lineNumber`


```js
var e = new Error("No fue posible analizar el dato introducido");
throw e;
console.log(e.lineNumber); // 2
```

### Ejemplo alternativo utilizando el evento '`error'`


```js
window.addEventListener("error", function (e) {
  console.log(e.lineno); // 5
});
var e = new Error("No fue posible analizar el dato introducido");
throw e;
```


Esta es una norma soportada por Chrome, Firefox entre otros.

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

No forma parte de ninguna especificación. No es una norma.

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

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

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

* `Error.prototype.stack` (en-US) 
Non-standard
* `Error.prototype.columnNumber` (en-US) 
Non-standard
* `Error.prototype.fileName` 
Non-standard
Error.prototype.toString()
==========================

El método **`toString()`** devuelve una cadena que representa el objeto `Error` especificado.

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

e.toString()
```

### Valor de retorno

Una cadena que representa el objeto `Error` especificado.

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

El objeto `Error` redefine el método `Object.prototype.toString()` heredado por todos los objetos. Su semántica es la siguiente (asumiendo que `Object` y `String` tienen sus valores originales):


```js
Error.prototype.toString = function () {
  "use strict";

  var obj = Object(this);
  if (obj !== this) {
    throw new TypeError();
  }

  var name = this.name;
  name = name === undefined ? "Error" : String(name);

  var msg = this.message;
  msg = msg === undefined ? "" : String(msg);

  if (name === "") {
    return msg;
  }
  if (msg === "") {
    return name;
  }

  return name + ": " + msg;
};
```

Ejemplos
--------

### Usar `toString()`


```js
var e = new Error("fatal error");
console.log(e.toString()); // 'Error: error fatal'

e.name = undefined;
console.log(e.toString()); // 'Error: error fatal'

e.name = "";
console.log(e.toString()); // 'error fatal'

e.message = undefined;
console.log(e.toString()); // ''

e.name = "hola";
console.log(e.toString()); // 'hola'
```

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

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

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

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

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

* `Error.prototype.toSource()`
Error.prototype.fileName
========================

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

La propiedad **`fileName`** contiene la ruta al archivo que generó este error.

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

Esta propiedad no estándar contiene la ruta al archivo que generó este error. Si se llama desde un contexto de depuración, devuelve las herramientas de desarrollo de Firefox, por ejemplo, "código de evaluación del depurador".

Ejemplos
--------

### Usar `fileName`


```js
var e = new Error("No se pudo procesar la entrada");
throw e;
// e.fileName podría verse como "file:///C:/ejemplo.html"
```

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.prototype.stack` (en-US)
* `Error.prototype.columnNumber` (en-US)
* `Error.prototype.lineNumber`
Error: cause
============

Los datos de la propiedad **`cause`** de una instancia de `Error` indica la causa original del error específico.

Se utiliza cuando se captura y se relanza un error con un mensaje de error más específico ó útil para seguir teniendo acceso al error original.

Valor
-----

El valor que se pasó al constructor del `Error()` en el argumento `options.cause`. Puede no estar presente.

| Atributos de la propiedad `Error: cause` |
| --- |
| Sobrescribir | Sí |
| Numerable | No |
| Configurable | Sí |

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

El valor de `cause` puede ser de cualquiér tipo. No debe suponer que el error que capturó tiene un `Error` como su `cause`, de la misma manera que no puede estar seguro que la variable enlazada en la instrucción `catch` sea un error tampoco. El siguiente ejemplo "Proporcionar datos estructurados como la causa del error" muestra un caso donde se proporciona deliberadamente un error como causa.

Ejemplos
--------

### Relanzando un error con una causa

 A veces es útil para detectar un error y volver a lanzarlo con un nuevo mensaje.
 En este caso debería pasar el error original al constructor para el nuevo `Error`, como se muestra.


```js
try {
  connectToDatabase();
} catch (err) {
  throw new Error("Falló la conexión a la base de datos.", { cause: err });
}
```


Para un ejemplo mas detallado vea Error > Diferenciar entre errores similares.

### Proporcionar datos estructurados como la causa del error

Los mensajes de error escritos para consumo humano pueden ser inapropiados para el análisis de la máquina — dado que están sujetos a cambios de redacción o puntuación que pueden romper cualquier análisis existente escrito para consumirlos. Así que, cuando lanza un error de una función, como una alternativa a un mensaje de error legible por humanos, puede proporcionar la causa como datos estructurados, para el análisis de la máquina.


```js
function makeRSA(p, q) {
  if (!Number.isInteger(p) || !Number.isInteger(q)) {
    throw new Error(
      "La generación de claves RSA requiere entradas de tipo entero.",
      {
        cause: { code: "NonInteger", values: [p, q] },
      },
    );
  }
  if (!areCoprime(p, q)) {
    throw new Error(
      "La generación de claves RSA requiere dos enteros coprimos.",
      {
        cause: { code: "NonCoprime", values: [p, q] },
      },
    );
  }
  // algoritmo rsa...
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-installerrorcause |

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

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

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

* `Error.prototype.message`
* `Error.prototype.toString()`
Error: message
==============

Los datos de la propiedad **`message`** de una instancia de `Error` es una descripción legible del error.

Valor
-----

Una cadena de texto correspondiente al valor pasado como primer parámetro del constructor `Error()`.

| Atributos de la propiedad `Error: message` |
| --- |
| Sobrescribir | Sí |
| Numerable | No |
| Configurable | Sí |

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

Esta propiedad contiene una breve descripción del error, si está disponible o ha sido establecido. Esta porpiedad combinada con la propiedad `name` es usada por el método `Error.prototype.toString()` para crear una cadena de texto del objeto Error.

Por defecto, la propiedad `message` es una cadena vacía, pero se puede especificar un mensaje a través del primer parámetro del constructor `Error`.

Ejemplos
--------

### Lanzar un error personalizado


```js
var e = new Error("No se pudo analizar la entrada");
// e.message es 'No se pudo analizar la entrada'
throw e;
```

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

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

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

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

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

* `Error.prototype.name`
* `Error.prototype.toString()`