JavaScript
Constantes incorporadas

Operaciones que devuelven NaN

Las operaciones matemáticas en valores distintos a los números devuelven NaN.

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

Una excepción: matrices de un solo número.

[2] * [3]  // Returns 6

Además, recuerde que el operador + concatena cadenas.

"a" + "b"  // Returns "ab"

La división de cero por cero devuelve NaN .

0 / 0         // NaN

Nota: En matemáticas en general (a diferencia de la programación de JavaScript), la división por cero no es posible.

Funciones de biblioteca de matemáticas que devuelven NaN

En general, las funciones Math que reciben argumentos no numéricos devolverán NaN.

Math.floor("a")

La raíz cuadrada de un número negativo devuelve NaN, porque Math.sqrt no admite números imaginarios o complejos .

Math.sqrt(-1)

Prueba de NaN usando isNaN ()

window.isNaN()

La función global isNaN() se puede usar para verificar si un determinado valor o expresión se evalúa como NaN . Esta función (en resumen) primero verifica si el valor es un número, si no intenta convertirlo (*), y luego verifica si el valor resultante es NaN . Por esta razón, este método de prueba puede causar confusión .

^{(*) El método de "conversión" no es tan simple, ver ECMA-262 18.2.3 para una explicación detallada del algoritmo.}

Estos ejemplos te ayudarán a comprender mejor el comportamiento de isNaN() :

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

Este último es un poco complicado: comprobar si una Array es NaN . Para hacer esto, el constructor Number() primero convierte la matriz a una cadena, luego a un número; esta es la razón por la que isNaN([]) y isNaN([34]) devuelven false , pero isNaN([1, 2]) y isNaN([true]) devuelven true : porque se convierten a "" , "34" , "1,2" y "true" respectivamente. En general, una matriz se considera NaN por isNaN() menos que solo contenga un elemento cuya representación de cadena pueda convertirse en un número válido .

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

nulo

null se utiliza para representar la ausencia intencional de un valor de objeto y es un valor primitivo. A diferencia de undefined , no es una propiedad del objeto global.

Es igual a undefined pero no idéntico a él.

null == undefined; // true
null === undefined; // false

CUIDADO: La typeof null es 'object' .

typeof null; // 'object';

Para verificar correctamente si un valor es null , compárelo con el operador de igualdad estricta

var a = null;

a === null; // true

indefinido y nulo

A primera vista, puede parecer que null e undefined son básicamente lo mismo, sin embargo, existen diferencias sutiles pero importantes.

undefined es la ausencia de un valor en el compilador, porque donde debería haber un valor, no se ha puesto uno, como en el caso de una variable no asignada.

• undefined es un valor global que representa la ausencia de un valor asignado.
  • typeof undefined === 'undefined'
• null es un objeto que indica que a una variable se le ha asignado explícitamente "sin valor".
  • typeof null === 'object'

Establecer una variable en undefined significa que la variable efectivamente no existe. Algunos procesos, como la serialización JSON, pueden quitar propiedades undefined de los objetos. En contraste, null propiedades null indican que se conservarán para que pueda transmitir explícitamente el concepto de una propiedad "vacía".

Los siguientes evalúan a undefined :

• Una variable cuando se declara pero no se le asigna un valor (es decir, se define)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• Accediendo al valor de una propiedad que no existe.

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• El valor de retorno de una función que no devuelve un valor

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• El valor de un argumento de función que se declara pero se ha omitido en la llamada de función

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined también es una propiedad del objeto de window global.

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

Infinito e -infinito

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity es una propiedad del objeto global (por lo tanto, una variable global) que representa el infinito matemático. Es una referencia a Number.POSITIVE_INFINITY

Es mayor que cualquier otro valor, y puede obtenerlo dividiendo por 0 o evaluando la expresión de un número que es tan grande que se desborda. En realidad, esto significa que no hay división por 0 errores en JavaScript, ¡hay Infinito!

También hay -Infinity que es infinito matemático negativo, y es más bajo que cualquier otro valor.

Para obtener -Infinity , niega el Infinity , u obtiene una referencia a este en Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Ahora vamos a divertirnos con ejemplos:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

Yaya

NaN significa "No es un número". Cuando una función u operación matemática en JavaScript no puede devolver un número específico, devuelve el valor NaN lugar.

Es una propiedad del objeto global y una referencia a Number.NaN

window.hasOwnProperty('NaN'); // true
NaN; // NaN

Tal vez confusamente, NaN todavía se considera un número.

typeof NaN; // 'number'

No compruebe si hay NaN utilizando el operador de igualdad. Ver isNaN en isNaN lugar.

NaN == NaN  // false
NaN === NaN // false

Constantes numéricas

El constructor de Number tiene algunas constantes integradas que pueden ser útiles

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

En muchos casos, los distintos operadores en Javascript se romperán con valores fuera del rango de ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Tenga en cuenta que Number.EPSILON representa la diferencia entre uno y el Number más pequeño mayor que uno, y por lo tanto la diferencia más pequeña posible entre dos valores de Number diferentes. Una razón para usar esto se debe a la naturaleza de la forma en que JavaScript almacena los números. Verifique la igualdad de dos números.