En JavaScript, las operaciones matemáticas se pueden implementar a través de dos operaciones:
1. +, -, *, /, % y otros operadores.
2. Use la función de cálculo del objeto matemático. Por ejemplo, use Math.Pow (2,3) para calcular la potencia de 2 a 3.
A diferencia de Java, las operaciones matemáticas en JavaScript no arrojan ningún error. El desbordamiento del resultado del cálculo, que se divide por 0, y los números negativos al cuadrado son todos legales, y el resultado es un valor especial en JavaScript: más o negativo infinito (infinito), más o negativo 0, nan (no número):
1. Infinito positivo y negativo. Cuando el resultado del cálculo es mayor que el número máximo que JavaScript puede representar (number.max_value), el resultado es un infinito positivo; Cuando el resultado del cálculo es menor que el número mínimo que JavaScript puede representar (-number.max_value), el resultado es un infinito negativo. Las operaciones matemáticas como +, -, *y / relacionadas con el infinito siguen las reglas de cálculo del límite en matemáticas avanzadas. El resultado de 1/0 es un infinito positivo, y el resultado de -1/0 es el infinito negativo.
2. Plus o menos 0. Cuando el resultado del cálculo es positivo pero menor que el decimal mínimo (número.min_value) que JavaScript puede representar, el resultado es positivo 0; Cuando el resultado del cálculo es negativo pero mayor que el decimal negativo máximo (-number.min_value) que JavaScript puede representar, el resultado es negativo 0. Generalmente, los desarrolladores no necesitan preocuparse por la diferencia entre más y menos 0.
3.NAN. Para algunos resultados de cálculo especiales que no se pueden representar incluso con un infinito positivo y negativo, JavaScript usa NAN para representarlos (vale la pena señalar que, aunque NAN literalmente significa "no número", su tipo es número). Estos cálculos especiales incluyen:
1) .0/0.
2). Infinity/Infinity.
3). Números negativos cuadrados.
4). Realice operaciones de conversión numérica en cadenas no numéricas.
Para Infinity y NAN, ambos son resultados de impresión "infinitos" y "no número número", y también son nombres de variables globales que representan estos dos valores especiales en JavaScript. De hecho, en Ecmascript 3, a estas dos variables globales también se les puede asignar otros valores; Esta regla loca se ha corregido en Ecmascript 5 para hacer que estas dos variables globales sean lecturas. Además de acceder directamente a la variable infinita y a la variable NAN, también puede usar estos dos valores especiales accediendo a las variables miembros del objeto número:
1.infinity es equivalente al número. Positivo_infinidad.
2. La infinidad es equivalente al número.
3.nan es equivalente al número.nan.
En JavaScript, NAN es un valor especial interesante, que tiene una propiedad especial: no es igual a ningún otro valor (incluido sí mismo). Hay dos formas de determinar si un valor es nan:
1. Para la variable x, determine si x! = X es verdadero. Esta expresión es verdadera solo si x es nan.
2. Para la variable x, llame a la función global ISNAN () en JavaScript para determinar si ISNAN (x) es verdadero. Este método determina que NAN no es realmente rigurosa, porque la expresión es NAN (x) es cierta en 4 casos:
1) .x es nan.
2) .x es una cadena, y la cadena no es un número.
3) .x es un objeto.
4) .x está indefinido.
Además de ISNAN (), JavaScript tiene otra función global útil: isFinite (). Para la variable a, isfinite (a) es cierto en los siguientes casos:
1) .a es número, pero no nan o positivo y negativo infinito.
2) .a es una cadena, pero el contenido de la cadena es un número de infinito no nan, no positivo.
3) .a es nulo.
4) .a es el valor booleano.
Dado que los tipos no numéricos, como NULL y UNDEFINADO, tendrán un impacto en el resultado, personalmente creo que es mejor juzgar el tipo de parámetro antes de usar isnan () o isfinite ().
experimento
La copia del código es la siguiente:
// Prueba de infinito
var a = number.max_value;
console.log (a*1.1); // infinito
console.log (A*-1.1); //-Infinito
console.log (1/0); // infinito
console.log (-1/0); //-infinito
// prueba positiva/negativa 0
var b = número.min_value;
console.log (b/2); // 0
console.log (-b/2); // 0
// prueba nan
console.log (0/0); // nan
console.log (Infinity/Infinity); // nan
console.log (math.sqrt (-1)); // nan
console.log (parseInt ("cadena")); // nan
// Probar la comparación de infinito
console.log (infinity === number.positivo_infinity); // Verdadero
console.log (-infinity === number.negative_infinity); // Verdadero
// Comparación NAN de prueba
console.log (nan === nan); // falso
// prueba isnan ()
console.log (isnan (nan)); // verdadero
console.log (isnan ("42")); // falso
console.log (isnan ("cadena")); // verdadero
console.log (isnan ({})); // verdadero
console.log (isnan (indefinido)); // verdadero
console.log (isnan (null)); // falso
// prueba isfinite ()
console.log (isFinite (42)); // Verdadero
console.log (isfinite (infinity)); // falso
console.log (isfinite (nan)); // falso
console.log (isFinite ("29")); // Verdadero
console.log (isFinite ("cadena")); // falso
console.log (isfinite (null)); // verdadero
console.log (isfinite (indefinido)); // falso
console.log (isfinite (true)); // true
console.log (isFinite (falso)); // verdadero