Js parte inteira quando dividida. Métodos para arredondar números em JavaScript

Neste artigo veremos detalhadamente números, operadores matemáticos, maneiras de converter um número em uma string e vice-versa, bem como muitos outros pontos importantes.

função isFinite

A função isFinite permite verificar se um argumento é um número finito.

Como resposta esta função retorna falso se o argumento for Infinity , -Infinity , NaN ou será convertido em um desses especiais valores numéricos. EM de outra forma esta função retornará true .

ÉFinito(73); // verdadeiro isFinite(-1/0); // false isFinite(Infinity); // falso isFinite(NaN); // false isFinite("Texto"); // falso

Exceto função global isFinite JavaScript também possui um método chamado Number.isFinite . Ao contrário de isFinite, não força a conversão do argumento em um número.

IsFinite("73"); // número verdadeiro.isFinite("73"); // falso

função isNaN

A função isNaN foi projetada para determinar se um argumento é um número ou pode ser convertido em um. Nesse caso, a função isNaN retorna falso. Caso contrário, ele retorna verdadeiro.

ÉNaN(NaN); //verdadeiro éNaN("25px"); //verdadeiro, porque 20px não é um número isNaN(25,5); //falso éNaN("25,5"); //falso éNaN(" "); //falso, porque um espaço ou vários espaços são convertidos em 0 isNaN(null); //falso, porque null é convertido em 0 isNaN(true); //falso, porque true é convertido em 1 isNaN(false); //falso, porque valor falso convertido para 0

Se esta ação precisar ser executada sem conversão de tipo, use o método Number.isNaN. Este método foi introduzido na linguagem a partir do ECMAScript 6.

Como converter explicitamente uma string em um número?

Você pode converter explicitamente uma string em um número usando os seguintes métodos:

1. Uso operador unário +, que deve ser colocado antes do valor.

+"7,35"; // 7,35 +"texto"; //NaN

Este método ignora espaços no início e no final da linha, bem como \n (alimentação de linha).

+"7,35"; //7,35 +"7,35\n"; //7,35

Usando este método Observe que uma string vazia ou uma string composta por espaços e \n é convertida no número 0. Além disso, também converte o tipo de dados nulo e os valores booleanos em um número.

Nulo; //0 +verdadeiro; //1 +falso; //0 +" "; //0

2. Função ParseInt. Esta função foi projetada para converter argumento para número inteiro. Ao contrário de usar operador unário +, este método permite converter uma string em um número, no qual nem todos os caracteres são numéricos. Ele começa a converter a string, começando pelo primeiro caractere. E assim que encontrar um caractere não numérico, esta função interrompe seu trabalho e retorna o número resultante.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Esta função pode funcionar com sistemas diferentes Números (binário, octal, decimal, hexadecimal). A base do sistema numérico é especificada usando 2 argumentos.

ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

Além da função parseInt, JavaScript possui o método Number.parseInt. Este método não é diferente da função parseInt e foi introduzido no JavaScript com a especificação ECMASCRIPT 2015 (6).

3. Função parseFloat. A função parseFloat é semelhante a parseInt , exceto que permite converter o argumento em um número fracionário.

ParseFloat("33,3%"); //33.3

Além disso, a função parseFloat, diferentemente de parseInt, não possui 2 argumentos e, portanto, sempre tenta tratar a string como um número no sistema de notação decimal.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

Além da função parseFloat, JavaScript possui o método Number.parseFloat. Este método não é diferente da função parseFloat e foi introduzido no JavaScript com a especificação ECMASCRIPT 2015 (6).

Convertendo um número em uma string

Você pode transformar um número em uma string usando o método toString.

(12.8).toString(); //"12,8"

O método toString também permite especificar a base do sistema numérico, levando em consideração que você precisa converter explicitamente o número em uma string:

(255).toString(16); //"ff"

Como verificar se uma variável é um número

Você pode determinar se o valor de uma variável é um número usando um dos seguintes métodos:

1. Usando as funções isNaN e isFinite:

// myVar é uma variável if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar é um número ou pode ser convertido nele);

Como função:

// função função isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(minhaVar)); //verdadeiro

Este método permite determinar se o valor especificado é um número ou pode ser convertido em um. Esta opção não conta a string vazia, string de espaços, null, Infinity, -Infinity, true e false como um número.

2. Usando o operador typeof e as funções isFinite, isNaN:

//função que verifica se o valor é um número function isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Esta função determina se o valor especificado é do tipo Número e também se pertence a um dos significados especiais Infinito, -Infinity e NaN. Se sim, então esta função retorna verdadeiro.

3. Usando o método ECMAScript 6 Number.isInteger(value). Este método permite determinar se o valor especificado é um número inteiro.

Número.isInteger("20"); //falso, porque este método não converte uma string em um número Number.isInteger(20); //verdadeiro, porque esse valor é um número

Números pares e ímpares

Você pode verificar se um número é par ou ímpar usando as seguintes funções:

// Função para verificar um número para paridade par function isEven(n) ( return n % 2 == 0; ) // Função para verificar um número para paridade ímpar function isOdd(n) ( return Math.abs(n % 2) == 1;

Mas antes de realizar tal verificação, é aconselhável certificar-se de que o valor especificado é um número:

Valor = 20; if (Number.isInteger(valor)) ( if (isEven(valor)) ( console.log("Número " + valor.toString() + " - par"); ) )

Números primos em Javascript

Vejamos um exemplo em que exibiremos números primos de 2 a 100 usando Javascript.

// Função que verifica se um número é primo function isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Arredondando um número em Javascript

Existem várias maneiras de arredondar uma fração para um número inteiro em JavaScript.

1. Utilizando os métodos Math.floor, Math.ceil e Math.round especialmente desenvolvidos para isso. O método Math.floor arredonda uma fração para o número inteiro mais próximo, ou seja, simplesmente descarta a parte fracionária. Math.ceil arredonda uma fração para o número inteiro mais próximo. Math.round arredonda um número para cima ou para baixo dependendo do valor da parte fracionária. Se a parte fracionária for maior ou igual a 0,5, então para cima, caso contrário a torção é para baixo.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Usando o método toFixed(precisão). Este método arredonda a parte fracionária de um número para uma precisão especificada. O resultado do arredondamento é retornado como uma string.

Console.log(7.987.toFixed(2)); //"7,99"

Se não houver casas decimais suficientes para formar a precisão especificada do número, ele será preenchido com zeros.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Usando o método toPrecision(precisão). Este método representa um número com uma precisão especificada. Ao mesmo tempo, ele pode arredondar não apenas a parte fracionária, mas também a parte inteira do número. Dependendo do resultado, este método pode apresentar o número resultante com ponto fixo ou na forma exponencial.

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Usando os operadores lógicos NOT ou OR.

//via negação lógica dupla console.log(~~7.9); //7 // usando OR lógico com zero: console.log(7.9^0); //7

Parte inteira e fracionária de um número

Você pode obter a parte inteira de um número usando os métodos Math.floor() e parseInt():

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); //7

Você pode obter a parte fracionária de um número usando o operador de porcentagem (%). Este operador retorna o resto que será obtido da divisão do primeiro número pelo segundo. Neste caso, você deve usar 1 como o segundo número.

Console.log(7,21%1); // 0,20999999999999996 // com precisão de 2 casas decimais console.log((7,21%1).toFixed(2)); // "0,21"

Além disso, a parte fracionária também pode ser obtida por meio de cálculos:

Número Var = 7,21; var fraçãoNumber = número - Math.floor(Math.abs(número)); console.log(fraçãoNumber); //0,20999999999999996

O número é divisível por um inteiro?

Você pode determinar se um número é divisível por um inteiro usando o operador de porcentagem:

Número Var = 9; // se o resto do número dividido por 3 for 0, então sim, caso contrário não if (number%3==0) ( console.log ("The number " + number + " is divisible by 3"); ) else ( console.log("O número " + número + " não é divisível por 3");

Formatando números

Em JavaScript, o método toLocaleString() permite formatar a saída de um número de acordo com os padrões regionais (configurações de idioma do sistema operacional).

Por exemplo, vamos formatar um número de acordo com os padrões regionais instalados no sistema por padrão:

Número Var = 345,46; console.log(número.toLocaleString()); //"345,46"

Por exemplo, vamos formatar o número de acordo com os padrões regionais da Rússia (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108,1"

Este método também pode ser usado para formatar um número como moeda:

Console.log((2540.125).toLocaleString("ru-RU",(estilo:"moeda", moeda:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(estilo:"moeda", moeda:"USD"))); //"89,30 $" console.log((2301.99).toLocaleString("ru-RU",(estilo:"moeda", moeda:"EUR"))); //"€2.301,99"

Representando um número como uma porcentagem:

Console.log((0.45).toLocaleString("ru-RU",(estilo:"porcentagem"))); //"45%"

Divida um número em dígitos (propriedade useGrouping):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125.452,32"

Imprima um número com um certo número de dígitos (2) após a vírgula:

Console.log((1240.4564).toLocaleString("ru-RU",(mínimoFractionDigits:2, máximoFractionDigits:2))); //"1.240,46"

Comparação de números

Os seguintes operadores são usados ​​para comparar números em JavaScript: == (igual), != (diferente), > (maior que),< (меньше), >= (maior ou igual a),<= (меньше или равно).

Por exemplo, vamos comparar dois números:

Console.log(2>3); //falso console.log(5>=3); //verdadeiro

Ao comparar números com parte fracionária, é necessário levar em consideração os erros que podem surgir durante esses cálculos.

Por exemplo, em JavaScript, a soma dos números (0,2 + 0,4) não é igual a 0,6:

Console.log((0,2+0,4)==0,6); //falso

Os erros ocorrem porque um computador ou outro dispositivo eletrônico realiza todos os cálculos no sistema de segundo número. Aqueles. Antes de realizar qualquer ação, o computador deve primeiro converter os números apresentados na expressão para o 2º sistema numérico. Mas nem todo número decimal fracionário pode ser representado exatamente no segundo sistema numérico.

Por exemplo, o número 0,25 10 é convertido exatamente em binário.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Por exemplo, o número 0,2 10 pode ser convertido no sistema 2 apenas com uma certa precisão:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1...0,2 10 = 0,001100110011...2

Como resultado, esses erros afetarão o cálculo da soma de dois números e os resultados da comparação. Aqueles. Acontece que o JavaScript verá esta entrada da seguinte maneira:

0.6000000000000001==0.6

Ao calcular ou exibir números com partes fracionárias, você deve sempre indicar a precisão com que deseja fazê-lo.

Por exemplo, compare números com até 2 casas decimais usando os métodos toFixed() e toPrecision():

//método toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //método toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //verdadeiro

Operações matemáticas básicas

Os seguintes operadores matemáticos existem em JavaScript: + (adição), - (subtração), * (multiplicação), / (divisão),% (módulo), ++ (aumentar um valor em 1), -- (diminuir um valor em 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, ou seja, 6:3=2 => 6-3*2 => rest(0) 5%2 //1, ou seja, 5:2=2(.5) => 5-2*2 => rest(1) 7,3%2 //1,3, ou seja, 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //o sinal do resultado da operação % é igual ao sinal do primeiro valor -9%2.5 //-1.5 , ou seja 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, ou seja 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, ou seja, 2:5=0(0,4) => 2-5*0 => descanso(2) x = 3; console.log(x++); // gera 3 e depois define 4 console.log(x); //4 x = 3; console.log(++x); //define 4 e gera x = 5; console.log(x--); // gera 5 e depois define 4 console.log(x); //4 x = 5; console.log(--x); //conjuntos 4 e saídas Além disso, JavaScript possui operadores de combinação: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).

x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3 Muitas vezes os cálculos produzem resultados que estão fora dos intervalos desejados. Como resultado, é necessário implementar Arredondamento JavaScript

até um determinado valor.

Por que arredondar números?

0.1 * 0.2; > 0.020000000000000004

JavaScript não armazena números inteiros porque seus valores são representados como números de ponto flutuante. Muitas frações não podem ser representadas como um número com um número finito específico de casas decimais, então o JavaScript pode gerar resultados como os seguintes:

Na prática, isso não fará diferença, pois estamos falando de um erro de 2 quintilionésimos. Mas isso pode afetar os resultados ao trabalhar com números que representam valores monetários, porcentagens ou tamanho de arquivo. Portanto, você precisa fazer ou até uma determinada casa decimal.

Para "cortar" um número decimal, use os métodos toFixed() ou toPrecision(). Ambos aceitam um argumento, que especifica o número de casas decimais e significativas a serem incluídas no resultado:

• se toFixed() não tiver nenhum argumento especificado, o valor padrão será 0 , ou seja, sem casas decimais; o valor máximo do argumento é 20;
• se nenhum argumento for fornecido para toPrecision(), o número não será alterado.

varNumRando = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" varNumRand = 87,335; RandNum.toFixed(2); > "87,33" varNumRand = 87,337; randNum.toPrecision(3); > "87,3"

Observação

Tanto toFixed() quanto toPrecision retornam uma representação de string arredondada do resultado, em vez de um número. Isso significa que adicionar arredondado a randNum resultará em uma concatenação de strings em vez de um único número:

console.log(randNum + arredondado); > "6.256"

Se você quiser que o JavaScript arredonde um número para os centésimos mais próximos, use parseFloat() :

varNumRando = 6,25; var arredondado = parseFloat(randNum.toFixed(1)); console.log(arredondado); > 6,3

toFixed() e toPrecision() também são métodos úteis para cortar grande quantidade casas decimais. Isto é útil ao trabalhar com números que representam unidades monetárias:

var wholeNum = 1 var dólaresCents = wholeNum.toFixed(2); console.log(dólaresCents); > "1,00"

Observe que se um número tiver mais dígitos do que a precisão especificada, toPrecision produzirá o resultado em formato científico:

var num = 123.435 num.toPrecision(2); > "1.2e+2"

Como evitar erros ao arredondar decimais

Em alguns casos, para implementar Fixo e para Precisão JavaScript arredondando 5 para baixo, e não para mais:

var numTest = 1,005; numTest.toFixed(2); > 1;

O resultado do exemplo acima deve ser 1,01, e não 1. Se quiser evitar esse erro, recomendo usar números exponenciais:

função round(valor, decimais) ( return Number(Math.round(value+"e"+decimais)+"e-"+decimais); )

Aplicativo:

rodada(1.005,2); > 1,01

Se você precisar de uma solução ainda mais robusta que o arredondamento, ela está disponível em MDN.

Arredondamento com épsilon

Método alternativo JavaScript arredondando para décimos foi introduzido no ES6 ( também conhecido como JavaScript 2015). « Máquina épsilon"fornece uma margem de erro razoável ao comparar dois números de ponto flutuante. Sem arredondamento, as comparações podem produzir resultados semelhantes aos seguintes:

0,1 + 0,2 === 0,3 > falso

Math.EPSILON pode ser usado em uma função para obter uma comparação válida:

função epsEqu(x, y) (retorna Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

A função leva dois argumentos: um contém os cálculos, o segundo o resultado esperado (arredondado). Ele retorna uma comparação destes dois parâmetros:

epsEqu(0,1 + 0,2, 0,3) > verdadeiro

Todos os navegadores modernos suportam funções matemáticas ES6. Mas se você precisar fornecer suporte em navegadores mais antigos, precisará usar polyfills.

Truncamento de números decimais

Todos os métodos apresentados anteriormente realizam JavaScript arredondando para décimos. Para truncar um número positivo com duas casas decimais, multiplique-o por 100, trunque-o novamente e divida o resultado por 100:

função truncada (num) ( return Math.trunc (num * 100)/100; ) truncada (3,1416) > 3,14

Se precisar de algo mais flexível, você pode usar o operador bit a bit:

função truncada (num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )

Uso:

var RandInt = 35,874993; truncado(randInt,3); > 35.874

Arredonde para o número mais próximo

Para implementar Arredondamento JavaScript para o número inteiro mais próximo, Math.round() é usado:

Rodada matemática (4,3) > 4 Rodada matemática (4,5) > 5

Observe que " meios valores", como 0,5, são arredondados.

Arredonde para o número inteiro mais próximo

Se quiser arredondar para baixo, use o método Math.floor():

Math.floor(42,23); > 42 Math.floor(36,93); > 36

O arredondamento para baixo tem uma direção para todos os números, inclusive os negativos. Isso pode ser imaginado como um arranha-céu com um número infinito de andares, inclusive abaixo do nível da fundação ( representando números negativos). Se você estiver no elevador entre os andares 2 e 3 do subsolo ( o que corresponde a um valor de -2,5), Math.floor levará você ao andar -3:

Math.floor(-2,5); > -3

Se você precisar evitar isso, use o arredondamento matemático JavaScript usando Math.trunc() , suportado em todos navegadores modernos(exceto IE/Edge):

Math.trunc(-41,43); > -41

A MDN também fornece polyfill de três linhas para fornecer suporte para Math.trunc em navegadores mais antigos e IE/Edge.

Arredonde para o número inteiro mais próximo

Se você quiser arredondar números decimais, use Math.ceil . Este método também pode ser pensado como um elevador infinito: Math.ceil sempre leva você “para cima”, independentemente de o número ser negativo ou positivo:

Math.ceil(42.23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); -36

Arredonde para o múltiplo mais próximo

Se você precisar arredondar um valor para o múltiplo de 5 mais próximo, crie uma função que divida o número por 5, arredonde-o e multiplique o resultado pelo mesmo valor:

função roundTo5(num) ( return Math.round(num/5)*5; )

Uso:

roundTo5(11); > 10

Se você precisar que o JavaScript arredonda para dois dígitos, poderá passar tanto a semente quanto o múltiplo para a função:

função roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )

Para utilizar a função, inclua o número a ser arredondado e o múltiplo em sua chamada:

var númeroInicial = 11; var múltiplo = 10; roundToMultiple(Número inicial, múltiplo); > 10;

Para arredondar valores apenas para cima ou para baixo, substitua round por teto ou piso na função.

Vinculação de intervalo

Às vezes você precisa obter um valor para x que deve estar dentro de um determinado intervalo. Por exemplo, precisamos de um valor de 1 a 100, mas obtemos o valor 123. Para corrigir isso você pode usar min() ( retorna o menor número) e máximo ( retorna o número máximo permitido).

Uso:

var limite baixo = 1; var limite alto = 100; var numInput = 123; var fixado = Math.max(lowBound, Math.min(numInput, highBound)); console.log(fixado); > 100;

Você pode criar uma função ou extensão da classe Number.

Por que o arredondamento é necessário?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Para efeitos práticos, esta imprecisão não importa, no nosso caso estamos falando de um erro em quintilhões de partes, porém, isso pode decepcionar alguns. Também podemos obter resultados um tanto estranhos ao trabalhar com números que representam moedas, porcentagens ou tamanhos de arquivo. Para corrigir essas imprecisões, basta conseguir arredondar os resultados, bastando definir a precisão decimal.

O arredondamento de números tem aplicações práticas, podemos manipular um número dentro de um determinado intervalo, por exemplo queremos arredondar um valor para o número inteiro mais próximo ao invés de trabalhar apenas com a parte decimal.

Arredondamento de números decimais

1. Se um argumento não for definido para toFixed(), o padrão será zero, o que significa 0 casas decimais, o argumento terá um valor máximo de 20.
2. Se nenhum argumento for fornecido para toPrecision, o número permanecerá inalterado

Seja RandNum = 6,25; deixe arredondado = randNum.toFixed(); // "6" console.log(randNum + arredondado); > "6.256"
Se quiser que o resultado seja um tipo de dados numérico, você precisará usar parseFloat:

Seja RandNum = 6,25; deixe arredondado = parseFloat(randNum.toFixed(1)); console.log(arredondado); > 6,3
Observe que os valores 5 são arredondados, exceto em casos raros.

Os métodos toFixed() e toPrecision() são úteis porque podem não apenas cortar a parte fracionária, mas também adicionar casas decimais, o que é conveniente ao trabalhar com moeda:

Deixe wholeNum = 1 deixe dólaresCents = wholeNum.toFixed(2); console.log(dólaresCents); > "1,00"
Observe que toPrecision produzirá o resultado em notação científica se o número de inteiros for maior que a própria precisão:

Seja num = 123,435 num.toPrecision(2); > "1.2e+2"

Como evitar erros de arredondamento com decimais

Seja numTest = 1,005; numTest.toFixed(2); > "1,00"
O resultado do cálculo acima deveria ter sido 1,01, e não 1. Se quisermos evitar um erro semelhante, podemos usar a solução proposta por Jack L Moore, que utiliza números exponenciais para o cálculo:

Função round(valor, decimais) ( return Number(Math.round(value+"e"+decimais)+"e-"+decimais); )
Agora:

Rodada(1.005,2); > 1,01
Se você deseja uma solução mais robusta que a mostrada acima, você pode ir para o MDN.

Arredondamento épsilon da máquina

0,1 + 0,2 === 0,3 > falso
Usamos Math.EPSILON em nossa função para obter uma comparação válida:

Função epsEqu(x, y) (retorna Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A função leva dois argumentos: o primeiro é o cálculo atual, o segundo é o resultado esperado. Ele retorna uma comparação dos dois:

EpsEqu(0,1 + 0,2, 0,3) > verdadeiro
Todos os navegadores modernos já suportam funções matemáticas ES6, mas se você quiser suporte em navegadores como o IE 11, use polyfills.

Cortando a parte fracionária

Função truncada(num) ( return Math.trunc(num * 100)/100; ) truncada(3,1416) > 3,14
Se você quiser adaptar o método para qualquer número de casas decimais, você pode usar a dupla negação bit a bit:

Função truncada(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Agora:

Seja randInt = 35,874993; truncado(randInt,3); > 35.874

Arredonde para o número mais próximo

Rodada matemática (4,3) > 4 Rodada matemática (4,5) > 5
Observe que “metade do valor”, 0,5 é arredondado de acordo com as regras da matemática.

Arredonde para o número inteiro mais próximo

Math.floor(42,23); > 42 Math.floor(36,93); > 36
Observe que o arredondamento funciona para todos os números, incluindo números negativos. Imagine um arranha-céu com um número infinito de andares, incluindo os andares do nível inferior (representando números negativos). Se você estiver em um elevador no nível mais baixo entre 2 e 3 (que representa um valor de -2,5), o Math.floor o levará para -3:

Math.floor(-2,5); > -3
Mas se você quiser evitar esta situação, use Math.trunc, suportado em todos os navegadores modernos (exceto IE/Edge):

Math.trunc(-41,43); > -41
No MDN você encontrará um polyfill que fornecerá suporte para Math.trunc em navegadores e IE/Edge.

Arredonde para o número inteiro mais próximo

Math.ceil(42.23); > 43 Math.ceil(36,93); > 37 Math.ceil(-36,93); > -36

Arredondando para cima/para baixo para o número necessário

Função roundTo5(num) ( return Math.round(num/5)*5; )
Agora:

RoundTo5(11); > 10
Se você quiser arredondar para múltiplos do seu valor, usamos uma função mais geral, passando para ela o valor inicial e o múltiplo:

Função roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Agora:

Seja númeroinicial = 11; seja múltiplo = 10; roundToMultiple(Número inicial, múltiplo); > 10;

Fixando um número em um intervalo

Deixe lowBound = 1; deixe highBound = 100; deixe numInput = 123; deixe preso = Math.max(lowBound, Math.min(numInput, highBound)); console.log(fixado); > 100;
Novamente, podemos reutilizar a operação e agrupar tudo em uma função, usando a solução proposta por Daniel X. Moore:

Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Agora:

NumInput.clamp (limite baixo, limite alto); > 100;

Arredondamento gaussiano

Função gaussRound(num, decimalPlaces) ( deixe d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Agora:

GaussRodada(2,5) > 2 gaussRodada(3,5) > 4 gaussRodada(2,57,1) > 2,6
Decimais em CSS:

Como o JavaScript é frequentemente usado para criar mapeamentos posicionais para elementos HTML, você pode estar se perguntando o que aconteceria se gerássemos valores decimais para nossos elementos:

#caixa (largura: 63,667731993px;)
A boa notícia é que os navegadores modernos respeitarão os valores decimais no modelo de bloco, incluindo porcentagem ou unidades de pixel.

Classificando

Classificando em ordem alfabética

Deixe fruta = ["abóbora", "damasco", "melão"]; fruta.sort(); > "damasco", "abóbora", "melão"]
No entanto, nos deparamos com um problema assim que um dos elementos estiver maiúsculo:

Deixe fruta = ["abóbora", "damasco", "Cantalope"]; fruta.sort(); > "Melão", "damasco", "abóbora"]
Isso ocorre porque, por padrão, o classificador compara o primeiro caractere representado em Unicode. Unicode é código único para qualquer símbolo, independentemente da plataforma, independentemente do programa, independentemente do idioma. Por exemplo, se você olhar a tabela de códigos, o caractere "a" tem o valor U+0061 (em hexadecimal 0x61), enquanto o caractere "C" tem o código U+0043 (0x43), que vem anteriormente no Unicode tabela do que o caractere "a".

Para classificar um array que pode conter primeiras letras com maiúsculas e minúsculas, precisamos converter todos os elementos temporariamente para minúsculas ou defina sua própria ordem de classificação usando o método localeCompare() com alguns argumentos. Via de regra, nesse caso, é melhor criar imediatamente uma função para uso repetido:

Função alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensibilidade": "base")); )); ) deixe fruta = ["abóbora ", "damasco", "melão"]; alfaClassificar(fruta) >
Se você quiser que o array seja classificado em ordem alfabética inversa, basta trocar as posições de a e b na função:

Função alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensibilidade": "base")); )); ) deixe fruta = ["abóbora ", "damasco", "melão"]; alphaSort(fruta) > ["Melão", "abóbora", "damasco"]
Aqui vale ressaltar que localeCompare é usado com argumentos, precisamos lembrar também que ele é suportado pelo IE11+, para versões mais antigas do IE, podemos usá-lo sem argumentos, e em letras minúsculas:

Função caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruta = ["abóbora", "damasco", "Melão"]; caseSort(fruta) > ["damasco", "abóbora", "melão"]

Classificação numérica

Deixe pontuações altas =; pontuações altas.sort(); >
O problema é que o método sort() realiza uma comparação lexicográfica: o que significa que os números serão convertidos em uma string e as comparações serão feitas novamente combinando o primeiro caractere dessa string na ordem dos caracteres na tabela Unicode . Portanto, precisamos novamente definir nossa ordem de classificação:

Deixe pontuações altas =; pontuações altas.sort(function(a,b) ( return a - b; )); >
Novamente, para classificar os números na ordem inversa, troque as posições de a e b na função.

Classificando uma estrutura semelhante a JSON

Deixe pontuações = [ ( "nome": "Daniel", "pontuação": 21768 ), ( "nome": "Michael", "pontuação": 33579 ), ( "nome": "Alison", "pontuação": 38395 ) ];
No ES6+, você pode usar funções de seta:

Pontuações.sort((a, b) => b.pontuação - a.pontuação));
Para navegadores mais antigos que não possuem esse suporte:

Scores.sort(function(a, b) ( return a.score - b.score ));
Como você pode ver, classificar em JavaScript é algo um tanto obscuro. Espero que esses exemplos facilitem a vida de alguma forma.

Trabalhando com funções de potência

Em JavaScript, a função de potência é representada como Math.pow(), e no novo padrão ES7, um novo operador de exponenciação foi introduzido - " * * ".

Exponenciação

Math.pow(3,2) > 9
Esta forma de notação significa 3 ao quadrado, ou 3 × 3, o que leva ao resultado 9. Outro exemplo pode ser dado, é claro:

Math.pow(5,3); > 125
Ou seja, 5 ao cubo, ou 5 × 5 × 5, é igual a 125.

ECMAScript 7 é a próxima versão do JavaScript, em princípio, podemos usar o novo operador de exponenciação proposto - * *, esta forma de notação pode ser mais descritiva:

3 ** 2 > 9
Sobre no momento O suporte para este operador é bastante limitado, portanto seu uso não é recomendado.

A função de potência pode ser útil na maioria situações diferentes. Um exemplo simples, calculando o número de segundos em uma hora: Math.pow (60,2).

Raízes quadradas e cúbicas

Matemática.sqrt(9) > 3
Ao mesmo tempo, a raiz cúbica de a é um número que dá a quando elevado a um cubo.

Matemática.cbrt(125) > 5
Math.cbrt() foi introduzido recentemente na especificação JavaScript e, portanto, só é compatível com navegadores modernos: Chrome 38+, Firefox e Opera 25+ e Safari 7.1+. Você notará isso Internet Explorer não está nesta lista, mas você encontrará um polyfill no MDN.

Exemplos

Math.pow(1,25, 2); > 1,5625 Matemática.cbrt(56,57) > 3,8387991760286138
Observe que isso também funciona muito bem ao usar valores de argumentos negativos:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
No entanto, isso não funcionará para raiz quadrada:

Math.sqrt(-9) > NaN
Pela análise matemática sabemos que um número imaginário se refere às raízes quadradas de números negativos. E isso pode nos levar a outra técnica para trabalhar com números complexos, mas isso é outra história.

Você pode usar frações em Math.pow() para encontrar as raízes quadradas e cúbicas dos números. A raiz quadrada usa um expoente de 0,5:

Math.pow(5, 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
No entanto, devido aos caprichos do ponto flutuante, você não consegue adivinhar exatamente o resultado correto:

Math.pow(2.23606797749979,2) > 5.000000000000001
Nessas situações, você terá que recorrer ao corte dos sinais do número ou ao arredondamento para algum valor.

Algumas pessoas, por razões desconhecidas, em JavaScript confundem a função Math.pow() com Math.exp() , que é a função exponencial para números em geral. Nota: em Inglês"expoente" é traduzido como "expoente", então é mais provável que isso se aplique a falantes de inglês, embora existam nomes alternativos para expoente, como índice, potência.

Constantes matemáticas

Math.abs, parseInt, parseFloat

Matemática.abs()

Seja novoVal = -57,64; Math.abs(novoVal); > 57,64
Math.abs(0) sempre retorna zero, mas se colocarmos um sinal de menos na frente da função -Math.abs(NUM) sempre obteremos um valor negativo.

Math.abs(0); > -0

analisarInt()

Sintaxe: parseInt(string, base);

A função parseInt converte o primeiro argumento passado para ela em um tipo string, interpreta-o e retorna um valor inteiro ou NaN. O resultado (se não for NaN) é um número inteiro e é o primeiro argumento (string), tratado como um número na raiz especificada. Por exemplo, a base 10 indica conversão de decimal, 8 de octal, 16 de hexadecimal e assim por diante. Se a base for maior que 10, serão usadas letras para representar números maiores que 9. Por exemplo, para números hexadecimais (base 16), são utilizadas as letras de A a F.

Vejamos um exemplo de trabalho com propriedades CSS, onde, relativamente falando, podemos obter o seguinte valor:

Deixe elem = document.body; deixe centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087,19px"
Podemos dividir os valores por espaços:

Deixe centros = centerPoint.split(" "); > ["454px", "2087,19px"]
Porém, cada elemento ainda é uma string, podemos nos livrar disso usando nossa função:

Seja centerX = parseInt(centers, 10); > 454 deixe centroY = parseInt(centros, 10); >2087
Como você pode ver, com o segundo argumento indicamos o sistema numérico para o qual o número será convertido; este parâmetro é opcional, mas é recomendado utilizá-lo caso você não saiba qual string será recebida como entrada.

analisarFloat()

Sintaxe: parseFloat(string)

Seja FP = "33,33333%"; console.log(parseFloat(FP)); > 33.33333
Observe que não há segundo argumento na sintaxe parseFloat.

Entendemos que parseInt() e parseFloat() são extremamente recursos úteis, é importante ressaltar que ainda existem alguns erros envolvidos, por isso é necessário verificar a faixa de valores esperados e por fim analisar o resultado para garantir que os valores obtidos estão corretos.
Enviar anonimamente

Neste artigo veremos detalhadamente números, operadores matemáticos, maneiras de converter um número em uma string e vice-versa, bem como muitos outros pontos importantes.

função isFinite

A função isFinite permite verificar se um argumento é um número finito.

Como resposta, esta função retorna falso se o argumento for Infinity, -Infinity, NaN ou for convertido em um desses valores numéricos especiais. Caso contrário, esta função retornará verdadeiro.

ÉFinito(73); // verdadeiro isFinite(-1/0); // false isFinite(Infinity); // falso isFinite(NaN); // false isFinite("Texto"); // falso

Além da função isFinite global, JavaScript também possui o método Number.isFinite. Ao contrário de isFinite, não força a conversão do argumento em um número.

IsFinite("73"); // número verdadeiro.isFinite("73"); // falso

função isNaN

A função isNaN foi projetada para determinar se um argumento é um número ou pode ser convertido em um. Nesse caso, a função isNaN retorna falso. Caso contrário, ele retorna verdadeiro.

ÉNaN(NaN); //verdadeiro éNaN("25px"); //verdadeiro, porque 20px não é um número isNaN(25,5); //falso éNaN("25,5"); //falso éNaN(" "); //falso, porque um espaço ou vários espaços são convertidos em 0 isNaN(null); //falso, porque null é convertido em 0 isNaN(true); //falso, porque true é convertido em 1 isNaN(false); //falso, porque falso é convertido para 0

Se esta ação precisar ser executada sem conversão de tipo, use o método Number.isNaN. Este método foi introduzido na linguagem a partir do ECMAScript 6.

Como converter explicitamente uma string em um número?

Você pode converter explicitamente uma string em um número usando os seguintes métodos:

1. Uso operador unário +, que deve ser colocado antes do valor.

+"7,35"; // 7,35 +"texto"; //NaN

Este método ignora espaços no início e no final da linha, bem como \n (alimentação de linha).

+"7,35"; //7,35 +"7,35\n"; //7,35

Usando este método, você precisa prestar atenção ao fato de que uma string vazia ou uma string composta por espaços e \n é convertida no número 0. Além disso, ele também converte o tipo de dados nulo e os valores booleanos em um número .

Nulo; //0 +verdadeiro; //1 +falso; //0 +" "; //0

2. Função ParseInt. Esta função foi projetada para converter argumento para número inteiro. Ao contrário de usar operador unário +, este método permite converter uma string em um número no qual nem todos os caracteres são numéricos. Ele começa a converter a string, começando pelo primeiro caractere. E assim que encontrar um caractere não numérico, esta função interrompe seu trabalho e retorna o número resultante.

ParseInt("18px"); //18 parseInt("33,3%"); //33

Esta função pode funcionar com diferentes sistemas numéricos (binário, octal, decimal, hexadecimal). A base do sistema numérico é especificada usando 2 argumentos.

ParseInt("18px", 10); //18 parseInt("33,3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

Além da função parseInt, JavaScript possui o método Number.parseInt. Este método não é diferente da função parseInt e foi introduzido no JavaScript com a especificação ECMASCRIPT 2015 (6).

3. Função parseFloat. A função parseFloat é semelhante a parseInt , exceto que permite converter o argumento em um número fracionário.

ParseFloat("33,3%"); //33.3

Além disso, a função parseFloat, diferentemente de parseInt, não possui 2 argumentos e, portanto, sempre tenta tratar a string como um número no sistema de notação decimal.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

Além da função parseFloat, JavaScript possui o método Number.parseFloat. Este método não é diferente da função parseFloat e foi introduzido no JavaScript com a especificação ECMASCRIPT 2015 (6).

Convertendo um número em uma string

Você pode transformar um número em uma string usando o método toString.

(12.8).toString(); //"12,8"

O método toString também permite especificar a base do sistema numérico, levando em consideração que você precisa converter explicitamente o número em uma string:

(255).toString(16); //"ff"

Como verificar se uma variável é um número

Você pode determinar se o valor de uma variável é um número usando um dos seguintes métodos:

1. Usando as funções isNaN e isFinite:

// myVar é uma variável if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar é um número ou pode ser convertido nele);

Como função:

// função função isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(minhaVar)); //verdadeiro

Este método permite determinar se o valor especificado é um número ou pode ser convertido em um. Esta opção não conta a string vazia, string de espaços, null, Infinity, -Infinity, true e false como um número.

2. Usando o operador typeof e as funções isFinite, isNaN:

//função que verifica se o valor é um número function isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Esta função determina se o valor especificado é do tipo Number e se é um dos valores especiais Infinity, -Infinity e NaN. Se sim, então esta função retorna verdadeiro.

3. Usando o método ECMAScript 6 Number.isInteger(value). Este método permite determinar se o valor especificado é um número inteiro.

Número.isInteger("20"); //falso, porque este método não converte uma string em um número Number.isInteger(20); //verdadeiro, porque esse valor é um número

Números pares e ímpares

Você pode verificar se um número é par ou ímpar usando as seguintes funções:

// Função para verificar um número para paridade par function isEven(n) ( return n % 2 == 0; ) // Função para verificar um número para paridade ímpar function isOdd(n) ( return Math.abs(n % 2) == 1;

Mas antes de realizar tal verificação, é aconselhável certificar-se de que o valor especificado é um número:

Valor = 20; if (Number.isInteger(valor)) ( if (isEven(valor)) ( console.log("Número " + valor.toString() + " - par"); ) )

Números primos em Javascript

Vejamos um exemplo em que exibiremos números primos de 2 a 100 usando Javascript.

// Função que verifica se um número é primo function isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Arredondando um número em Javascript

Existem várias maneiras de arredondar uma fração para um número inteiro em JavaScript.

1. Utilizando os métodos Math.floor, Math.ceil e Math.round especialmente desenvolvidos para isso. O método Math.floor arredonda uma fração para o número inteiro mais próximo, ou seja, simplesmente descarta a parte fracionária. Math.ceil arredonda uma fração para o número inteiro mais próximo. Math.round arredonda um número para cima ou para baixo dependendo do valor da parte fracionária. Se a parte fracionária for maior ou igual a 0,5, então para cima, caso contrário a torção é para baixo.

Console.log(Math.floor(7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. Usando o método toFixed(precisão). Este método arredonda a parte fracionária de um número para uma precisão especificada. O resultado do arredondamento é retornado como uma string.

Console.log(7.987.toFixed(2)); //"7,99"

Se não houver casas decimais suficientes para formar a precisão especificada do número, ele será preenchido com zeros.

Console.log(7.987.toFixed(5)); //"7.98700"

3. Usando o método toPrecision(precisão). Este método representa um número com uma precisão especificada. Ao mesmo tempo, ele pode arredondar não apenas a parte fracionária, mas também a parte inteira do número. Dependendo do resultado, este método pode apresentar o número resultante com ponto fixo ou na forma exponencial.

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. Usando os operadores lógicos NOT ou OR.

//via negação lógica dupla console.log(~~7.9); //7 // usando OR lógico com zero: console.log(7.9^0); //7

Parte inteira e fracionária de um número

Você pode obter a parte inteira de um número usando os métodos Math.floor() e parseInt():

Console.log(Math.floor(7.21)); // 7 console.log(parseInt(7.21)); //7

Você pode obter a parte fracionária de um número usando o operador de porcentagem (%). Este operador retorna o resto que será obtido da divisão do primeiro número pelo segundo. Neste caso, você deve usar 1 como o segundo número.

Console.log(7,21%1); // 0,20999999999999996 // com precisão de 2 casas decimais console.log((7,21%1).toFixed(2)); // "0,21"

Além disso, a parte fracionária também pode ser obtida por meio de cálculos:

Número Var = 7,21; var fraçãoNumber = número - Math.floor(Math.abs(número)); console.log(fraçãoNumber); //0,20999999999999996

O número é divisível por um inteiro?

Você pode determinar se um número é divisível por um inteiro usando o operador de porcentagem:

Número Var = 9; // se o resto do número dividido por 3 for 0, então sim, caso contrário não if (number%3==0) ( console.log ("The number " + number + " is divisible by 3"); ) else ( console.log("O número " + número + " não é divisível por 3");

Formatando números

Em JavaScript, o método toLocaleString() permite formatar a saída de um número de acordo com os padrões regionais (configurações de idioma do sistema operacional).

Por exemplo, vamos formatar um número de acordo com os padrões regionais instalados no sistema por padrão:

Número Var = 345,46; console.log(número.toLocaleString()); //"345,46"

Por exemplo, vamos formatar o número de acordo com os padrões regionais da Rússia (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108,1"

Este método também pode ser usado para formatar um número como moeda:

Console.log((2540.125).toLocaleString("ru-RU",(estilo:"moeda", moeda:"RUB"))); //"2.540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(estilo:"moeda", moeda:"USD"))); //"89,30 $" console.log((2301.99).toLocaleString("ru-RU",(estilo:"moeda", moeda:"EUR"))); //"€2.301,99"

Representando um número como uma porcentagem:

Console.log((0.45).toLocaleString("ru-RU",(estilo:"porcentagem"))); //"45%"

Divida um número em dígitos (propriedade useGrouping):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125.452,32"

Imprima um número com um certo número de dígitos (2) após a vírgula:

Console.log((1240.4564).toLocaleString("ru-RU",(mínimoFractionDigits:2, máximoFractionDigits:2))); //"1.240,46"

Comparação de números

Os seguintes operadores são usados ​​para comparar números em JavaScript: == (igual), != (diferente), > (maior que),< (меньше), >= (maior ou igual a),<= (меньше или равно).

Por exemplo, vamos comparar dois números:

Console.log(2>3); //falso console.log(5>=3); //verdadeiro

Ao comparar números com parte fracionária, é necessário levar em consideração os erros que podem surgir durante esses cálculos.

Por exemplo, em JavaScript, a soma dos números (0,2 + 0,4) não é igual a 0,6:

Console.log((0,2+0,4)==0,6); //falso

Os erros ocorrem porque um computador ou outro dispositivo eletrônico realiza todos os cálculos no sistema de segundo número. Aqueles. Antes de realizar qualquer ação, o computador deve primeiro converter os números apresentados na expressão para o 2º sistema numérico. Mas nem todo número decimal fracionário pode ser representado exatamente no segundo sistema numérico.

Por exemplo, o número 0,25 10 é convertido exatamente em binário.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Por exemplo, o número 0,2 10 pode ser convertido no sistema 2 apenas com uma certa precisão:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1...0,2 10 = 0,001100110011...2

Como resultado, esses erros afetarão o cálculo da soma de dois números e os resultados da comparação. Aqueles. Acontece que o JavaScript verá esta entrada da seguinte maneira:

0.6000000000000001==0.6

Ao calcular ou exibir números com partes fracionárias, você deve sempre indicar a precisão com que deseja fazê-lo.

Por exemplo, compare números com até 2 casas decimais usando os métodos toFixed() e toPrecision():

//método toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //método toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //verdadeiro

Operações matemáticas básicas

Os seguintes operadores matemáticos existem em JavaScript: + (adição), - (subtração), * (multiplicação), / (divisão),% (módulo), ++ (aumentar um valor em 1), -- (diminuir um valor em 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, ou seja, 6:3=2 => 6-3*2 => rest(0) 5%2 //1, ou seja, 5:2=2(.5) => 5-2*2 => rest(1) 7,3%2 //1,3, ou seja, 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //o sinal do resultado da operação % é igual ao sinal do primeiro valor -9%2.5 //-1.5 , ou seja 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, ou seja 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, ou seja, 2:5=0(0,4) => 2-5*0 => descanso(2) x = 3; console.log(x++); // gera 3 e depois define 4 console.log(x); //4 x = 3; console.log(++x); //define 4 e gera x = 5; console.log(x--); // gera 5 e depois define 4 console.log(x); //4 x = 5; console.log(--x); //conjuntos 4 e saídas Além disso, JavaScript possui operadores de combinação: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).