No JavaScript, as operações matemáticas podem ser implementadas através de duas operações:
1. +, -, *, /, % e outros operadores.
2. Use a função de cálculo do objeto de matemática. Por exemplo, use Math.pow (2,3) para calcular a potência de 2 a 3.
Ao contrário do Java, as operações matemáticas no JavaScript não lançam erros. O transbordamento do resultado do cálculo, dividido por 0, e números negativos ao quadrado são todos legais, e o resultado é um valor especial em JavaScript: mais ou infinito negativo (infinito), mais ou negativo 0, NAN (não-número):
1. Infinidade positiva e negativa. Quando o resultado do cálculo é maior que o número máximo que JavaScript pode representar (número.max_value), o resultado é uma infinidade positiva; Quando o resultado do cálculo é menor que o número mínimo que JavaScript pode representar (-number.max_value), o resultado é uma infinidade negativa. As operações matemáticas como +, -, *e / relacionadas ao infinito seguem as regras de cálculo de limite em matemática avançada. O resultado de 1/0 é o infinito positivo e o resultado de -1/0 é infinito negativo.
2. Mais ou menos 0. Quando o resultado do cálculo é positivo, mas menor que o decimal mínimo (número.Min_Value) que o JavaScript pode representar, o resultado é positivo 0; Quando o resultado do cálculo é negativo, mas maior que o decimal negativo máximo (-number.min_value) que o JavaScript pode representar, o resultado é negativo 0. Geralmente, os desenvolvedores não precisam se preocupar com a diferença entre mais e menos 0.
3.nan. Para alguns resultados especiais de cálculo que não podem ser representados, mesmo com infinito positivo e negativo, o JavaScript usa a NAN para representá-los (vale a pena notar que, embora NAN literalmente signifique "não-número", seu tipo é número). Esses cálculos especiais incluem:
1) .0/0.
2). Infinidade/infinito.
3). Números negativos quadrados.
4). Realize operações de conversão numérica em cordas não numéricas.
Para o infinito e a NAN, ambos são resultados de impressão "infinitos" e "não-número" e também são nomes de variáveis globais que representam esses dois valores especiais em JavaScript. De fato, no ECMAScript 3, essas duas variáveis globais também podem receber outros valores; Essa regra maluca foi corrigida no Ecmascript 5 para tornar essas duas variáveis globais somente leitura. Além de acessar diretamente a variável infinita e a variável NAN, você também pode usar esses dois valores especiais acessando as variáveis de membro do objeto Number:
1.Infinity é equivalente ao número.positivo_infinity.
2. Infinidade é equivalente ao número.negative_infinity.
3.Nan é equivalente a number.nan.
No JavaScript, a NAN é um valor especial interessante, que possui uma propriedade especial: não é igual a nenhum outro valor (inclusive em si). Existem duas maneiras de determinar se um valor é NAN:
1. Para a variável x, determine se x! = X é verdadeiro. Essa expressão é verdadeira apenas se x for nan.
2. Para a variável x, chame a função global isnan () em javascript para determinar se o isnan (x) é verdadeiro. Este método determina que a NAN não é realmente rigorosa, porque a expressão isnan (x) é verdadeira em 4 casos:
1) .x é nan.
2) .x é uma string e a string não é um número.
3) .x é um objeto.
4) .x é indefinido.
Além de isnan (), o JavaScript possui outra função global útil: isfinite (). Para a variável A, a isfinita (a) é verdadeira nos seguintes casos:
1) .a é número, mas não nan ou infinidade positiva e negativa.
2) .a é uma corda, mas o conteúdo da string é um número de infinito não-NAN e não positivo.
3) .a é nulo.
4) .a é o valor booleano.
Como tipos não numéricos, como nulo e indefinido, terão um impacto no resultado, eu pessoalmente acho que é melhor julgar o tipo de parâmetro antes de usar o isnan () ou isfinite ().
experimentar
A cópia do código é a seguinte:
// Teste o infinito
var a = número.max_value;
console.log (a*1.1); // infinito
console.log (a*-1.1); //-infinito
console.log (1/0); // infinito
console.log (-1/0); //-infinito
// Teste positivo/negativo 0
var b = número.min_value;
console.log (b/2); // 0
console.log (-b/2); // 0
// Test Nan
console.log (0/0); // nan
console.log (infinito/infinito); // nan
console.log (math.sqrt (-1)); // nan
console.log (parseint ("string")); // nan
// Teste a comparação do infinito
console.log (infinito === número.positivo_infinity); // true
console.log (-infinity === Número.negative_infinity); // true
// Teste a comparação de nan
console.log (nan === nan); // false
// teste isnan ()
console.log (isnan (nan)); // true
console.log (isnan ("42")); // false
console.log (isnan ("string")); // true
console.log (isnan ({})); // true
console.log (isnan (indefinido)); // true
console.log (isnan (nulo)); // false
// teste isfinite ()
console.log (isfinite (42)); // true
console.log (isfinite (infinito)); // false
console.log (isfinite (nan)); // false
console.log (isfinite ("29")); // true
console.log (isfinite ("string")); // false
console.log (isfinite (nulo)); // true
console.log (isfinite (indefinido)); // false
console.log (isfinite (true)); // true
console.log (isfinite (false)); // true