Olá, amantes Javascript-a. Você já percebeu que esta linguagem é muito extraordinária e em cada seção se destaca por suas peculiaridades e soluções técnicas incomuns. Portanto, a publicação de hoje é dedicada ao tópico: Arredondamento de JavaScript.

Depois de ler o artigo atual, você descobrirá por que é necessário arredondar os números, quais métodos e propriedades em JS realizam essa função, bem como a divisão de 0. Sem alterar seus princípios, vou anexar exemplos a pontos-chave de o material e escreva cada ação em detalhes. Agora vamos começar a aprender!

Notas importantes sobre números

Para começar, lembre-se que em JS todos os tipos de números (fracionário e inteiro) referem-se ao tipo Número. Além disso, todos eles são de 64 bits, pois são armazenados no formato "Double Precision", que também é conhecido sob o padrão IEEE-754.

Criou variáveis \u200b\u200bnuméricas com a maneira usual:

var permanente \u003d 35; // número natural

vaR Drob \u003d 0,93; // representação decimal

vars numb16 \u003d 0xff; // 16-richery System

Suporta outras visualizações numéricas. Portanto, você também pode criar números com um ponto flutuante (eles às vezes são chamados de "números no formato científico").

Apareceu o suporte para um método muito interessante tolocalestring ()Quais formata todos os parâmetros numéricos de acordo com as especificações prescritas no ECMA 402. Devido a esses grandes números, números de telefone, moedas e até mesmo percentuais são lindamente exibidos na caixa de diálogo.

var num \u003d 714000,80;

alerta (num.tolocalestring ());

Para trabalhar com elementos do número do tipo, todo um objeto global com um monte de todos os tipos de funções matemáticas, cujo nome Matemática..

Além disso, existem outros métodos que realizam valores numéricos de arredondamento para inteiros, até décimos, centésimos, etc. Considere-os mais.

Ótima e poderosa matemática

O objeto de matemática global inclui um grande número de várias funções matemáticas e trigonométricas. Este é um objeto muito necessário e geralmente corta os desenvolvedores ao trabalhar com dados digitais.

Em outras plataformas, existem analogias de matemática. Por exemplo, em idiomas populares, como Java e C #, a matemática é uma classe que suporta todas as mesmas funções padrão. Então, como você vê esta ferramenta é muito grande e poderoso.

Agora quero passar pelos métodos específicos responsáveis \u200b\u200bpelo arredondamento e conte sobre eles em detalhes.

Math.floor ()

Eu vou começar S. Matemática.andar. Preste atenção ao nome do método. É claro que fica claro que, uma vez que estamos falando de arredondamento, e a tradução literal da palavra "chão" significa "andar", então esta ferramenta completa os valores processados \u200b\u200bem uma linha reta menor.

Uma opção também é possível quando o número processado usando esta função permanece o mesmo. Tudo porque o arredondamento é realizado em desigualdade não neural (<=). Таким образом, при отработке этой строчки кода:

alerta (math.floor (4.5));

a resposta será o número 4.

Math.ceil ()

Mais uma vez, olhe para o nome (em tal método, o material é rapidamente absorvido). Se alguém não sabe, "Ceil" significa "teto". Isso significa que o arredondamento dos dados numéricos será realizado no lado mais alto, usando uma não-desigualdade (\u003e \u003d).

alerta (math.ceil (4.5));

Como você já adivinhou, a resposta será o número 5.

Math.round ()

Este método arredonda o número fracionário para o todo mais próximo. Portanto, se a parte fracionária estiver no intervalo de 0 e a 0,5 não inclusive, a arredondamento ocorre em um valor menor. E se a parte fracionária estiver no intervalo de 0,5 e até o próximo inteiro, é arredondado para um todo maior.

alerta (matemática (4.5));

Espero que todos pensem ou contassem a resposta correta - 5.

Mais alguns métodos

JavaScript também tem outros dois métodos que estão envolvidos em arredondamento de representações numéricas. No entanto, eles são um pouco diferentes.

Será sobre esses instrumentos como tofixed () e toprecision (). Eles respondem não apenas para arredondamento, mas por sua precisão a certos sinais. Vamos lutar mais fundo.

tofixed ()

Com este mecanismo, você pode especificar, a quantos sinais após a vírgula precisa rodar o valor. O método retorna o resultado como uma string. Abaixo eu anexei uma opção com três opções diferentes. Analisar as respostas recebidas.

var num \u003d 5656.9393;

document.writeln (num.ToFixed ()); // 5657.

document.writeln (num.ToFixed (2)); // 5656.94.

document.writeln (num.ToFixed (7)); // 5656.9393000.

Como pode ser visto, se você não especificar o argumento, então tofixed ()) rodou o valor fracionário para todo números. Na terceira linha completou o arredondamento até 2 caracterese no quarto - por causa do parâmetro "7", mais três 0 foram abordados.

toprecision ()

Este método age um pouco de forma diferente. No local do argumento, você pode deixar um lugar vazio e definir o parâmetro. No entanto, o último arredondará os números antes do número especificado de números, não prestando atenção à vírgula. Aqui estão os resultados do programa reescrito desde o passado:

var num \u003d 5656.9393;

document.writeln (num.Toprecision ()); // 5656.9393.

document.writeln (num.Toprecision (2)); // 5.7E + 3

document.writeln (num.Toprecision (7)); // 5656.939.

Arquivo de Divisão em 0 em JS

Como é conhecido de lições em matemática, é impossível dividir para zero. Esta regra levou como base a maioria dos criadores de linguagens de programação. Portanto, ao dividir para zero, todos os programas dão um erro.

No entanto, JavaScript se distinguiu aqui. Então, durante a execução de tal operação, não surge mensagens de bugs ... porque tal operação retorna "Infinidade"!

Por quê então? Como é conhecido das mesmas ciências matemáticas, quanto menor o divisor, o resultado é um número maior. É por isso que os criadores dessa linguagem orientada ao protótipo decidiram abandonar os modelos e seguir seu próprio caminho.

Para aqueles que são enfrentados pela primeira vez com o valor do infinito, abaixo expliquei suas características.

Infinito - significa infinito e coincide plenamente o sinal matemático ∞.

Pode ser negativo. Todas as regras padrão para trabalhar com operadores aritméticos também são salvas.

alerta (12/0); // infinito.

alerta (12.34 / 0); // infinito.

alerta (-3 / 0); // -infinity.

Neste, talvez e termine. Se você gosta da publicação, então certifique-se de se inscrever no meu blog. Não tenha uma referência a artigos interessantes e compartilhe-os com amigos. Tchau tchau!

Javascript-mathematics, arredondando até duas casas decimais (9)

Eu tenho a seguinte sintaxe javascript:

Var desconto \u003d math.round (100 - (preço / listprice) * 100);

Isso é arredondado para um inteiro. Como posso devolver o resultado com dois sinais decimais?

Aqui está um exemplo de trabalho

Valor var \u003d 200.2365455; Resultado \u003d math.round (valor * 100) / 100 // resultado será 200.24

Para processamento de arredondamento para qualquer número de casas decimais para a maioria das necessidades, haverá função suficiente com 2 linhas de código. Aqui está um código de exemplo para o jogo.

VaR Vestnum \u003d 134.9567654; Var decpl \u003d 2; var testres \u003d rounddec (testnum, decpla); Alerta (Testnum + "arredondado para" + decpla + "casas decimais é" + testres); Função RoundDec (NBR, DEC_PLACES) (var mult \u003d math.pow (10, deckplaces); retorno math.round (NBR * MULT) / MULT;)

A melhor e simples solução que encontrei é

Rodada de função (número de retorno (matemática.round (valor + e "+ decimais) +" e - "+ decimais);) Rodada (1,005, 2); // 1.01.

Pequena variação da resposta aceita. Tofixed (2) retorna a string e você sempre obterá dois sinais decimais. Pode ser zeros. Se você quiser suprimir o (s) zero (s) final, basta fazer isso:

Var desconto \u003d + ((preço / listprice) .TOFixed (2));

Editado: Acabei de descobrir que parece um erro no Firefox 35.0.1, o que significa que o acima pode dar aos nan alguns valores.
Eu mudei meu código em

Var desconto \u003d math.round (preço / listprice * 100) / 100;

Isso dá um número com uma precisão de duas casas decimais. Se você precisar de três, multiplicará e dividirá 1000 e assim por diante.
OP quer duas descargas decimais sempre, mas se tofixed () é quebrado no Firefox, primeiro você precisa consertá-lo.
Veja https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.

Para obter um resultado com dois sinais decimais, você pode fazer o seguinte:

Var desconto \u003d math.round ((100 - (Preço / listim) * 100) * 100) / 100;

O valor que precisa ser arredondado é multiplicado por 100 para salvar os dois primeiros dígitos, então dividimos 100 para obter o resultado real.

Eu acho que a melhor maneira que vi é multiplicada por 10 por número de números, então faça Math.Round e, finalmente, divida 10 por número de números. Aqui está uma função simples que eu uso em textos digitais:

Função RoundToxDigits (Valor: Número, Dígitos: Número) (valor \u003d valor * Math.pow (10, dígitos); valor \u003d math.round (valor); valor \u003d valor / matemática.pow (10, dígitos); valor de retorno; )

Ou simples javascript:

Função RoundToxDigits (valor, dígitos) (se (! Dígitos) (dígitos \u003d 2;) valor \u003d valor * matemática.pow (10, dígitos); valor \u003d math.round (valor); valor \u003d valor / matemática.pow (10 , dígitos); valor de retorno;)

NOTA. - Veja editar 4 se a precisão de 3 dígitos é importante.

Var desconto \u003d (preço / listprice) .TOFixed (2);

o tofixed é arredondado para cima ou para baixo para você, dependendo dos valores superiores a 2 sinais decimais.

Mudar. Como mencionado por outros, ele converte o resultado na string. Para evitar isso:

Var desconto \u003d + ((preço / listprice) .TOFixed (2));

Editando 2. - Como mencionado nos comentários, esta função não é executada com alguma precisão, por exemplo, no caso de 1,005 retornará 1,00 em vez de 1,01. Se a precisão é importante para tal ponto, encontrei esta resposta: https: //.com/a/32605063/1726511 O que parece funcionar bem com todos os testes que eu tentei.

Uma pequena modificação requer, mas a resposta indicada acima retorna inteiros quando é arredondada para um, portanto, por exemplo, 99.004 retornará 99 em vez de 99,00, o que não é perfeito para exibição de preço.

Editar 3. - Parece que o tofixed no retorno real de ainda torceu alguns números, é a edição final parece funcionar. Geez tantas reparações!

Var desconto \u003d roundto ((preço / listprice), 2); Função rodada (n, dígitos) (if (dígitos \u003d\u003d\u003d undefined) (dígitos \u003d 0;) var multiplicator \u003d Math.pow (10, dígitos); n \u003d parsefloat ((n * multiplicator) .TOFixed (11)); var test \u003d (math.round (n) / multiplicator); return + (test.tofixed (dígitos));)

Editar 4. "Vocês me matam." Editar 3 falha em números negativos, sem cavar por que é mais fácil simplesmente fazer um número negativo positivo antes de fazer o arredondamento e, em seguida, devolvê-lo antes de retornar o resultado.

Função rodada a (n, dígitos) (var negativo \u003d false; se (dígitos \u003d\u003d\u003d indefinidos) (dígitos \u003d 0;) se (n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

O caminho mais rápido - mais rápido que tofixed ():

Dois decaliles

x \u003d .123456 resultado \u003d math.round (x * 100) / 100 // resultado .12

Três decimalidades

x \u003d .123456 resultado \u003d math.round (x * 1000) / 1000 // resultado .123

Função Rodada (Num, Dec) (num \u003d Math.Round (Num + E "+ Dez) Número de retorno (Num +" E - "+ DEC)) // rodada a um decimal de sua escolha: Rodada (1.3453)

Olá. Hoje, na coluna JavaScript, veremos como definir o Javascript o número de mesolinas nos números de ponto flutuante. Por exemplo, você precisa deixar 3 sinal decimal ao exibir ou apenas dois.

Tarefa: Javascript Número de ponto e vírgula

Assim, nos deparamos com a tarefa: há resultado de cálculos, nos quais há números antes dos ponto e vírgula, e após a vírgula. Decimal. Suponha que o resultado terminasse este 1538.9891200153. Mas quando a saída deve ser o número refletindo a quantidade, onde a quantidade de notas é até a vírgula e depois - Kopecks.

Existem várias maneiras de resolver esta tarefa.

Solução 1: Javascript Número de ponto e vírgula com o método tofixed

tOFIXED é um método incorporado no JavaScript que é aplicado a qualquer número, a precisão leva uma arredondamento de precisão (ou seja, o número de caracteres do mares).

Var num \u003d 1538,9891200153; num_str \u003d num.tofixed (); // num_str \u003d 1538; num_str \u003d num.tofixed (2); //Num_str\u003d1538.98; num_str \u003d num.tofixed (5); //Num_str\u003d1538.98912;

O parâmetro de precisão nesta função deve ser de pelo menos 0 (não assume valores negativos) e não mais de 20.

Você também pode fazer sem uma variável, por exemplo, assim:

Num_str \u003d (1538.9891200153) .TOFixed (2); //Num_str\u003d1538.98;

Solução 2: Número Javascript de Semicolons com o método TopRecision

Esta solução é baseada no mesmo método de javascript integrado. Uma característica distintiva desse método é que o parâmetro tomado para a entrada indica não precisão (o número de vírgulas), mas o número total de caracteres (tanto para a vírgula quanto depois).

Var num \u003d 1538,9891200153; num_str \u003d num.toprecision (5); //Num_str\u003d1538.9; num_str \u003d num.toprecision (7); //Num_str\u003d1538.989;

Solução sem sinais após uma vírgula: Javascript Número de vírgulas

Se os sinais decimais precisam estar completamente dobrados, isto é, é necessário arredondar o número fracionário para o todo, então você pode usar as funções da matemática: rodada, téu e chão.
Rodadas - rodadas em um lado grande ou menor (dependendo do número). Se o valor após o ponto e vírgula for mais da metade, então rodou para todo o lado, se menos - a menor. Isto é, se 0,51 - será 1, se 0,49 - 0.

CEIL - Do inglês. O teto é sempre arredondado no maior lado.

Chão - do inglês. Paul está sempre em um lado menor.

Var num \u003d 1538,9891200153; num_str \u003d math.round (num); // num_str \u003d 1539; num_str \u003d math.floor (num); // num_str \u003d 1538; num_str \u003d math.ceil (num); // num_str \u003d 1539;

Isso é tudo. Espero que esta nota te ajudasse a resolver a tarefa. Se algo falhou - faça perguntas usando o botão verde "Faça uma pergunta por um especialista", ou nos comentários.

Muitas vezes os cálculos dão resultados que não correspondem aos limites das faixas desejadas. Como resultado, você precisa se exercitar Arredondamento de JavaScript. até um certo valor.

Por que números redondos?

O JavaScript não armazena inteiros, já que seus valores são apresentados na forma de um número de pontos flutuantes. Muitas frações não podem ser representadas por um número com um certo número finito de ponto e vírgula, então JavaScript pode gerar resultados, como o seguinte:

0.1 * 0.2; > 0.020000000000000004

Na prática, não terá importância, uma vez que chega ao erro em 2 quinilonne. Mas isso pode afetar o resultado ao trabalhar com números que representam valores da válvula, por cento ou tamanho do arquivo. Portanto, você precisa fazer ou até um certo sinal decimal.

Arredondando números decimais

Para "aparar" um número decimal, os métodos Tofixed () ou TopRecision () são usados. Ambos tomam um argumento que determina o número de significativos e marcas após a vírgula, que deve ser incluída no resultado:

• se for tofixed (), o argumento não estiver definido, o valor padrão é 0, ou seja, sem sinais após a vírgula; O valor máximo do argumento é 20;
• se para TopRecision (), o argumento não for especificado, o número não é alterado.

var randnum \u003d 6,25; randnum.tofixed (); \u003e "6" math.pi.toprecision (1); \u003e "3" var randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" varandnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"

Observação

E tofixed () e toprecision retornam uma representação em minúsculas arredondadas e não um número. Isso significa que adicionar um Randnum resultará em uma string concontina, e não um número:

console.log (randnum + arredondado); \u003e "6.256"

Se você precisar obter um arredondamento de javascript para os centésimos, use Parsefloat ():

var randnum \u003d 6,25; var arredondado \u003d parsefloat (randnum.tofixed (1)); Console.log (arredondado); \u003e 6.3.

tofixed () e TopRecision () também são métodos úteis para truncar um grande número de vírgulas. É conveniente ao trabalhar com números representando unidades monetárias:

var wholenum \u003d 1 dolar dolares \u003d wholenum.tofixed (2); Console.log (dolares); \u003e "1,00"

Por favor, note que se houver mais sinais do que o parâmetro de precisão especificado, o TopRecision emitirá um resultado em um formato científico:

var num \u003d 123.435 num.toprecision (2); \u003e "1.2E + 2"

Como evitar erros ao arredondar frações decimais

Em alguns casos, tofixed e toprecision é realizado Javascript arredondando 5 para um lado menor, não até mais:

var numtest \u003d 1,005; numtest.tofixed (2); \u003e 1;

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

rodada de função (número de retorno (matemática.round (valor + e "+ decimais) +" e - "+ decimais);)

Aplicativo:

rodada (1,005,2); \u003e 1.01.

Se você precisar de uma solução ainda mais confiável do que o arredondamento, ele está disponível em Mdn..

Arredondamento com epsilon

Método alternativo Javascript arredondando até décimos foi introduzido no ES6 ( também conhecido como JavaScript 2015). « Epsilon da máquina.»Fornece um limite de erro razoável ao comparar dois ponto-e-vírgulas flutuantes. Sem arredondamento, comparações podem dar resultados como segue:

0,1 + 0.2 \u003d\u003d\u003d 0.3\u003e FALSE

Math.epsilon pode ser usado na função para obter uma comparação correta:

função Epons (x, Y) (retorno math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Função leva dois argumentos: Um contém cálculos, o segundo resultado esperado (arredondado). Retorna uma comparação desses dois parâmetros:

eQUEL (0,1 + 0,2, 0,3)\u003e Verdadeiro

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

Truncamento de números decimais

Todos os métodos apresentados anteriormente executam Javascript arredondando até décimos. Para aparar um número positivo de até dois lugares após a vírgula, multiplique-o a 100, a calha novamente e, em seguida, o resultado obtido é dividido por 100, você precisa:

função truncada (num) (retorno math.trunc (num * 100) / 100;) truncado (3.1416)\u003e 3.14

Se algo mais flexível for necessário, você pode usar o operador quebrado:

função truncada (var numpowerconverter \u003d math.pow (10, decimalplacas); return ~~ (num * numpowerconverter) / numpowerconverter;)

Usando:

var randint \u003d 35.874993; Truncado (Randint, 3); \u003e 35.874.

Arredondando para o número mais próximo

Implementar Javascript arredondando para o todo, Math.round () é usado:

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5

Observe que " meio valores", Como 0,5, arredondado.

Arredondando até o inteiro mais próximo

Se você quiser redondar em um lado menor, use o método math.floor ():

Matemática (42.23); \u003e 42 Math.floor (36.93); \u003e 36.

O arredondamento "para baixo" tem uma direção para todos os números, inclusive para negativo. Isso pode ser representado como um arranha-céu com um número infinito de pisos, incluindo abaixo do nível da fundação ( representando números negativos). Se você está no elevador entre os pisos do porão 2 e 3 ( o que corresponde ao valor -2.5), Math.floor vai entregá-lo ao chão -3:

Math.floor (-2,5); \u003e -3.

Se você quiser evitar isso, use o Javascript Math Arredonding usando Math.trunc () suportado em todos os navegadores modernos (exceto Ie / borda):

Math.trunc (-41,43); \u003e -41.

O MDN também fornece polfill de três linhas para fornecer suporte math.trunc em navegadores antigos e ie / borda.

Arredondando até o inteiro mais próximo

Se você quiser completar os números decimais, use o Math.ceil. A ação desse método também pode ser representada como um elevador sem fim: Math.ceil é sempre sortudo "up", independentemente de o número negativo ou positivo:

Math.ceil (42.23); \u003e 43 Math.ceil (36.93); \u003e 37 math.ceil (-36,93); -36.

Arredondando para o número múltiplo mais próximo

Se você precisar arredondar o valor para o número mais próximo, vários 5, criar uma função que divide o número para 5, arredonda e, em seguida, multiplica o resultado no mesmo valor:

função Roundto5 (num) (retorno math.round (num / 5) * 5;)

Usando:

roundto5 (11); \u003e 10.

Se você quiser executar o Javascript arredondando até dois caracteres, você pode transmitir funções como o número inicial e a multiplicidade:

função RoundtoMultiple (num, múltiplo) (retorno matemática.round (num / múltiplo) * múltiplos;)

Para usar a função, ligue o número arredondado e a multiplicidade em sua chamada:

var inicialnumber \u003d 11; var múltiplo \u003d 10; RoundtoMultiple (inverno, múltiplo); \u003e 10;

Para arredondar os valores apenas em uma direção grande ou menor, substitua na função redonda no CEIL ou no chão.

Encadernação a alcance

Às vezes você precisa obter o valor X, que deve estar dentro de um determinado intervalo. Por exemplo, você precisa de um valor de 1 a 100, mas recebemos o valor 123. Para consertá-lo, você pode usar min () ( retorna o menor dos números) e max ( retorna o número máximo permitido).

Usando:

var baixo \u003d 1; var hipbound \u003d 100; Var NumInput \u003d 123; var aperfeiçoado \u003d matemática.max (lowbound, matemática (numimput, alta)); Console.log (preso); \u003e 100;

Você pode criar uma função ou número de classe de extensão.

Muitas vezes, os cálculos em JavaScript não fornecem os resultados que queremos. Claro, podemos fazer com números qualquer coisa - arredondando em um lado grande ou menor, definir os intervalos, cortar números desnecessários para um certo número de casas decimais, tudo depende do que você deseja fazer no futuro com esse número.

Por que você precisa de arredondamentos?

Um dos curiosos aspectos do JavaScript é que ele realmente não armazena inteiros, trabalhamos imediatamente com números de ponto flutuante. Isso, em combinação com o fato de que muitos valores fracionários não podem ser expressos pelo número final de sinais decimais, podemos obter esses resultados em JavaScript:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Para fins práticos, esta imprecisão não importa, no nosso caso, estamos falando de erro em dólares de Quintillion, no entanto, alguém pode decepcionar. Podemos obter um resultado ligeiramente estranho e ao trabalhar com números que são valores de válvulas, por cento ou tamanhos de arquivo. Para corrigir essas imprecisões, só precisamos ser capazes de arredondar os resultados, enquanto basta estabelecer a precisão decimal.

O arredondamento dos números tem aplicação prática, podemos manipular o número em um determinado intervalo, por exemplo, queremos arredondar o valor para o inteiro mais próximo, e não funcionar apenas com a parte decimal.

Arredondando números decimais

Para cortar o número decimal, use o método tofixed ou toprecision. Ambos são tomados por um único argumento que determina, respectivamente, quantos números significativos (isto é, o número total de números usados \u200b\u200bentre o número) ou após um ponto-e-vírgula (quantidade após o ponto decimal) deve incluir o resultado:

1. Se o argumento não estiver definido para tofixed (), então, por padrão, será zero, o que significa 0 marcas após a vírgula, o argumento tem um valor máximo igual a 20.
2. Se o argumento não for especificado para toprecision, o número permanece intocado

Deixe randnum \u003d 6,25; randnum.tofixed (); \u003e "6" math.pi.toprecision (1); \u003e "3" randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" randnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"
Ambos os métodos TOFixed () e TopRecision () retornam uma representação de string do resultado, não um número. Isso significa que, ao somar o valor arredondado com o Randnum, o concatenato de linhas será feito e não a quantidade de números:

Deixe randnum \u003d 6,25; Deixe arredondado \u003d randnum.tofixed (); // "6" console.log (randnum + arredondado); \u003e "6.256"
Se você quiser que o resultado tenha um tipo de dados numérico, você precisará aplicar parsefloat:

Deixe randnum \u003d 6,25; Deixe arredondado \u003d parsefloat (randnum.tofixed (1)); Console.log (arredondado); \u003e 6.3.
Por favor, note que 5 valores são arredondados, com exceção de casos raros.

Os métodos Tofixed () e TopRecision () são úteis, porque eles não podem apenas cortar a parte fracionária, mas também complementar os sinais após a vírgula, que é conveniente ao trabalhar com moeda:

Deixe wholenum \u003d 1 deixar dolares \u003d wholenum.tofixed (2); Console.log (dolares); \u003e "1,00"
Condição Observe que a TopRecision dará o resultado em um registro exponencial se o número de inteiros for maior que a própria precisão:

Deixe num \u003d 123.435 num.toprecision (2); \u003e "1.2E + 2"

Como evitar erros de arredondamento com números decimais

Em alguns casos, tofixed e toprecision rodam o valor 5 para um lado menor e em um grande:

Deixe numtest \u003d 1,005; numtest.tofixed (2); \u003e "1,00"
O resultado do cálculo acima era de 1,01, e não 1. Se você quiser evitar um erro semelhante, podemos usar a solução proposta por Jack L Moore, que usa números exponenciais para calcular:

Rodada de função (número de retorno (matemática.round (valor + e "+ decimais) +" e - "+ decimais);)
Agora:

Rodada (1,005,2); \u003e 1.01.
Se você quiser uma solução mais confiável do que a solução mostrada acima, você pode ir para o MDN.

Tronco de epsilon da máquina.

O método alternativo de arredondamento de números decimais foi introduzido no ES6. A tronco de Epsilon da máquina fornece um limite de erro razoável ao comparar dois números de ponto flutuante. Sem arredondamento, comparações podem dar resultados como segue:

0,1 + 0.2 \u003d\u003d\u003d 0.3\u003e FALSE
Nós usamos math.epsilon em nossa função para obter uma comparação correta:

Função Epons (x, Y) (retorno math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A função recebe dois argumentos: o primeiro cálculo atual, o segundo é o resultado esperado. Retorna uma comparação de dois:

EQUEL (0,1 + 0,2, 0,3)\u003e Verdadeiro
Todos os navegadores modernos já estão suportando funções matemáticas ES6, mas se você quiser obter suporte em navegadores, como o IE 11, use polifills.

Cortando parte fracionária

Todos os métodos apresentados acima são capazes de rodar para números decimais. Para simplesmente cortar o número até dois sinais após a vírgula, você deve primeiro multiplicar por 100, e então o resultado obtido já está dividido por 100:

Função truncada (num) (retorno math.trunc (num * 100) / 100;) truncado (3.1416)\u003e 3.14
Se você quiser adaptar o método para qualquer número de ponto e vírgula, você pode usar uma negação bitty duplo:

Função truncada (permite que numpowerconverter \u003d math.pow (10, decimalplacas); return ~~ (numpowerconverter) / numpowerconverter;)
Agora:

Deixe randint \u003d 35.874993; Truncado (Randint, 3); \u003e 35.874.

Arredondando para o número mais próximo

Para arredondar o número decimal para o número mais próximo em mais ou de um lado menor, dependendo do que estamos mais próximos, use math.round ():

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5
Por favor, note que "metade do valor", 0,5 é arredondada em uma direção grande de acordo com as regras da matemática.

Arredondando para um menor para o inteiro mais próximo

Se você quiser sempre redondo em um lado menor, use matemática.

Matemática (42.23); \u003e 42 Math.floor (36.93); \u003e 36.
Por favor, note que o arredondamento em um lado menor funciona para todos os números, inclusive para negativo. Imagine um arranha-céu com um número infinito de pisos, incluindo os pisos de baixo nível (representando números negativos). Se você estiver no elevador no nível inferior entre 2 e 3 (que é um valor -2,5), o Math.Floor irá entregá-lo a -3:

Math.floor (-2,5); \u003e -3.
Mas se você quiser evitar uma situação semelhante, use Math.trunc, suportado em todos os navegadores modernos (exceto ou seja / borda):

Math.trunc (-41,43); \u003e -41.
Você encontrará Polyfill no MDN para fornecer suporte math.trunc nos navegadores e ou seja / borda.

Arredondando para mais para o inteiro mais próximo

Por outro lado, se você sempre precisar rodar até o maior, use math.ceil. Mais uma vez, lembre-se do interminável elevador: Math.ceil sempre subirá, não importa se o número é negativo ou não:

Math.ceil (42.23); \u003e 43 Math.ceil (36,93); \u003e 37 math.ceil (-36,93); \u003e -36.

Arredondando para um número maior / menor

Se quisermos arredondar até o número mais próximo, vários 5, a maneira mais fácil de criar uma função que divide o número em 5 rodadas, e então multiplica-a à mesma quantidade:

Função Roundto5 (num) (retorno math.round (num / 5) * 5;)
Agora:

Roundto5 (11); \u003e 10.
Se você quiser rodar para vários valor, usamos uma função mais geral passando o valor inicial e múltiplos a ele:

Função RoundtoMultiple (num, múltiplo) (retorno matemática.round (num / múltiplo) * múltiplos;)
Agora:

Deixe o inverno \u003d 11; Deixe vários \u003d 10; RoundtoMultiple (inverno, múltiplo); \u003e 10;

Corrigindo o número no intervalo

Há muitos casos em que queremos obter o valor de X deitado dentro do intervalo. Por exemplo, podemos precisar de um valor de 1 a 100, mas ao mesmo tempo recebemos um valor de 123. Para corrigi-lo, podemos usar o mínimo (retorna o menor do número de números) e o máximo ( retorna o maior de vários números). Em nosso exemplo, o intervalo de 1 a 100:

Deixe lowbound \u003d 1; Deixe alta \u003d 100; Deixe Numinput \u003d 123; Deixe apertar \u003d matemática.max (lowbound, matemática (numimput, alta)); Console.log (preso); \u003e 100;
Mais uma vez, podemos reutilizar a operação e envolver tudo na função, usamos a solução proposta por Daniel X. Moore:

Número.Prototype.clamp \u003d Função (min, max) (retorno matemática.min (math.max (isto, min), max););
Agora:

Numinput.clamp (lowbound, alta); \u003e 100;

Arredondamento gaussiano.

Arredondamento Gaussiano, também conhecido como arredondamento bancário, é que o arredondamento para este caso ocorre para o preto mais próximo. Este método de arredondamento funciona sem um erro estatístico. A melhor solução foi proposta por Tim Down:

Função gaussround (Seja d \u003d decimalplaces || 0, m \u003d math.pow (10, d), n \u003d + (d? Num * m: num) .tofixed (8), i \u003d math.floor (n), f \u003d n - i, e \u003d 1E-8, r \u003d (f\u003e 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Agora:

Gaussround (2.5)\u003e 2 Gaussround (3.5)\u003e 4 Gaussround (2.57,1)\u003e 2.6
Sinal decimal em CSS:

Como o JavaScript é freqüentemente usado para criar uma conversão posicional de elementos HTML, você pode se perguntar o que acontece se gerarmos valores decimais para nossos itens:

#Box (largura: 63.667731993px;)
Boas notícias é que os navegadores modernos levarão em conta valores decimais em um modelo de bloco, incluindo em porcentagem ou pixels de medição.

Ordenação

Muitas vezes, temos que classificar quaisquer elementos, por exemplo, temos uma matriz de registros de jogos, enquanto eles devem ser organizados como ordem decrescente de jogadores. Infelizmente, o método padrão () tem algumas restrições incríveis: funciona bem com palavras inglesas usadas com freqüência, mas imediatamente quebra em uma reunião com números, caracteres originais ou palavras na maiúscula.

Classifique em ordem alfabética

Parece que a classificação da matriz deve ser a tarefa mais simples:

Deixe fruta \u003d ["squash butternut", "damasco", "cantaloupe"]; fruta.sort (); \u003e "Damasco", "butternut squash", "cantaloupe"]
No entanto, estamos confrontados com o problema assim que um dos elementos está na maiúscula:

Deixe frutas \u003d ["Butternut Squash", "Aprot", "cantalope"]; fruta.sort (); \u003e "Cantaloupe", "Aprot", "Butternut Squash"]
Isso se deve ao fato de que, por padrão, o classificador compara o primeiro símbolo apresentado no Unicode. O Unicode é um código único para qualquer símbolo, independentemente da plataforma, independentemente do programa, independentemente do idioma. Por exemplo, se você olhar através da tabela de código, o caractere "A" é U + 0061 (no sistema hexadecimal 0x61), enquanto o símbolo "C" tiver código U + 0043 (0x43), que vai antes na tabela Unicode do que o símbolo "A".

Para classificar uma matriz que pode conter registros mistos das primeiras letras, precisamos converter todos os itens para temporariamente no registro inferior ou determinar sua ordem de classificação usando o método localecompare () com alguns argumentos. Como regra, para tal caso, é melhor criar imediatamente uma função para uso repetido:

Função Alfasor (ARR) (Retorna A.LocalCompare (B, PT ", (" sensibilidade ":" base "))););) Deixe frutas \u003d [" squash butternut "," damasco "," cantaloupe "]; AlphaSort (fruta)\u003e
Se você quiser obter um array classificado na ordem alfabética inversa, basta alterar as posições A e B para a função:

Função Alfastro (ARR) (Retornar B.LocalCompare (A, EN ", (" sensibilidade ":" base "))););) Deixe fruta \u003d [" squash butternut "," damasco "," cantaloupe "]; Alfrastar (fruta)\u003e ["cantaloupe", "Butternut Squash", "Apricot"]
Vale a pena prestar atenção a que o localCompare é usado com argumentos, ainda é necessário lembrar que é suportado pelo IE11 +, para versões mais antigas, podemos usá-lo sem argumentos, e no registro inferior:

Caixas de função (ARR) (Return a.tolowercase (). LocalEcompare (b.tolowercase ());));) Deixe frutas \u003d ["squash butternut", "damasco", "cantaloupe"]; Capestesort\u003e [Damasco, "Butternut Squash", "Cantaloupe"]

Classificação numérica

Tudo isso não se aplica ao exemplo do qual falamos sobre a matriz acima dos registros do jogo. Com algumas matrizes numéricas, a classificação funciona perfeitamente, mas em algum momento, o resultado pode ser imprevisível:

Deixe Highscores \u003d; Highscores.Sort (); \u003e
O fato é que o método do tipo () produz uma comparação lexicográfica: e isso significa que os números serão convertidos em uma string e comparações serão realizados novamente mapeando o primeiro caractere dessa string nos símbolos da tabela Unicode. Portanto, precisamos determinar sua ordem de classificação:

Deixe Highscores \u003d; Highscores.Sort (Retorna A - B;)); \u003e
Novamente, para classificar números na ordem inversa, altere as posições A e B para a função.

Ordenar a estrutura do JSON

E finalmente, se tivermos uma estrutura de dados semelhante a JSON, representadas como uma matriz de registros de jogos:

Deixe escores \u003d [("nome": "Daniel", "Pontuação": 21768), ("Nome": "Michael", "Pontuação": 33579), ("nome": "Alison", "Alison": 38395 )];
No ES6 +, você pode usar as funções de seta:

Pontuações.sort ((a, b) \u003d\u003e b.score - a.score));
Para navegadores antigos que não têm esse suporte:

Pontuações.sort (retorne a.score - B.Score));
Como você pode ver, classificar em Javascript é uma coisa bastante óbvia, espero que esses exemplos possam facilmente para a vida.

Trabalhe com funções de energia

O exercício é uma operação, originalmente definida como resultado de várias multiplicação de um número natural em si, uma raiz quadrada do número A é um número dado a um quadrado. Com essas funções, poderíamos desfrutar constantemente na vida cotidiana em lições de matemática, incluindo ao calcular áreas, volumes ou até mesmo modelagem física.

Em JavaScript, uma função de energia é representada como matemática .Pow (), no novo padrão ES7, um novo operador de exercícios foi apresentado ao grau - "* *".

Erendar em grau

Para construir um número no grau N-UY, use a função Math.Pow (), onde o primeiro argumento é o número que será erguido em um grau, o segundo argumento é um indicador do grau:

Math.pow (3.2)\u003e 9
Essa forma de gravação significa 3 em um quadrado, ou 3 × 3, que resulta em um resultado 9. Outro exemplo pode ser dado, claro:

Math.pow (5.3); \u003e 125.
Isto é, 5 em Cuba, ou 5 × 5 × 5, igual a 125.

Ecmascript 7 é a seguinte versão do JavaScript, em princípio, podemos usar o novo operador de exercício proposto em um grau - * *, tal forma de gravação pode ser mais visual:

3 ** 2 > 9
No momento, o suporte para este operador é bastante limitado, por isso não é recomendado usá-lo.

A poderosa função pode ser útil em várias situações. Um exemplo simples, calculando o número de segundos em uma hora: Math.pow (60.2).

Raiz quadrada e cúbica

Math.sqrt () e math.cbrt () são opostos às funções math.pow (). Como nos lembramos, a raiz quadrada do número A é um número que dá um quando o quadrado é erguido.

Math.sqrt (9)\u003e 3
Ao mesmo tempo, a raiz cúbica do número A é um número que dá um quando o cubo é erguido.

Math.cbrt (125)\u003e 5
Math.cbrt () foi introduzido na especificação JavaScript recentemente e, portanto, suportado apenas em navegadores modernos: Chrome 38+, Firefox e Opera 25+ e Safari 7.1+. Você notará que o Internet Explorer está faltando nesta lista, no entanto, você encontrará Polyfill no MDN.

Exemplos

Claro, podemos usar e não inteiro em uma dessas funções:

Math.pow (1,25, 2); \u003e 1.5625 math.cbrt (56.57)\u003e 3.8387991760286138
Por favor, note que funciona muito bem ao usar valores negativos de argumentos:

Math.pow (-5.2)\u003e 25 Math.pow (10, -2)\u003e 0.01
No entanto, para uma raiz quadrada não funcionará:

Math.sqrt (-9)\u003e nan
Da análise matemática, sabemos que sob número imaginário eles entendem raízes quadradas de números negativos. E isso pode nos levar a outra técnica de trabalhar com números complexos, mas esta é outra história.

Você pode usar valores fracionários no Math.pow () para encontrar números quadrados e cúbicos de raízes. A raiz quadrada usa um indicador 0,5:

Math.pow (5, 0,5); // \u003d math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
No entanto, devido a caprichos de ponto flutuante, você não pode assumir com precisão o resultado correto:

Math.pow (2.23606797749979,2)\u003e 5.0000000000001
Em tais situações, você terá que recorrer a sinais de corte em números ou arredondamentos para qualquer valor.

Alguns, por razões incompreensíveis em JavaScript confundem a função Math.pow () com Math.Exp (), que é uma função exponencial para números como um todo. Nota: Em inglês, o indicador "Expoente" é traduzido como "exponente", então se refere ao inglês, embora existam nomes de indicadores alternativos, como índice, energia.

Constantes matemáticas

Trabalhar com a matemática em Javascript é facilitado por uma série de constantes embutidas. Essas constantes são as propriedades do objeto de matemática. Vale a pena notar que as constantes são escritas na maiúscula, e não notação de camelcase.

Math.abs, parseint, parsefloat

Trabalhar com números em javascript pode ser muito mais complicado do que parece. Os valores obtidos nem sempre se enquadram nas faixas esperadas, às vezes o resultado pode não ser de todo o que esperávamos.

Math.abs ()

MATH.ABS () Método Retorna o valor absoluto do número, que nos lembra a mesma função matemática do número A.

Deixe o NewVal \u003d -57,64; Math.abs (newval); \u003e 57.64.
Math.Abs \u200b\u200b(0) sempre retorna zero, mas se você colocar um sinal de menos antes da função -math.abs (num), sempre seremos um valor negativo.

Math.abs (0); \u003e -0.

parseint ()

Sabemos que o JavaScript entende que "15" é uma string, e não um número e, por exemplo, ao analisar propriedades CSS com JavaScript com qualquer valor de uma matriz despreparada, nossos resultados podem ser imprevisíveis. Poderíamos entrar na linha de entrada representada como "17px", e para nós não é raro. A questão é como converter esta seqüência no valor real e usá-lo em cálculos adicionais.

Sintaxe: Parseint (string, radix);

O recurso Parseint converte o primeiro argumento transmitido a ele em um tipo de string, interpreta e retorna um inteiro ou valor nan. O resultado (se não NAN) é um inteiro e representa o primeiro argumento (string), que é considerado como um número no sistema de números especificado (RADIX). Por exemplo, a base 10 indica uma conversão de um número decimal, 8 - octal, 16 hexadecimal e assim por diante. Se a base for maior que 10, as letras são usadas para designar números mais de 9. Por exemplo, para números hexadecimais (base 16), letras de A a F.

Considere um exemplo de trabalho com propriedades CSS, onde, convencionalmente falando, podemos obter esse valor:

Deixe Elem \u003d Document.Boody; Deixe Centerpoint \u003d Window.GetComputedStyle (Elem) .TransformaRigin; \u003e "454px 2087.19px"
Podemos dividir os valores em espaços:

Deixe Centers \u003d Centerpoint.Split (""); \u003e ["" 454px "," 2087.19px "]
No entanto, cada elemento ainda é uma string, podemos se livrar dele aplicando nossa função:

Deixe Centerx \u003d Parseint (Centros, 10); \u003e 454 Deixe Centery \u003d Parseint (Centers, 10); \u003e 2087.
Como você pode ver, especificamos o número do número ao qual o número será convertido para o qual este parâmetro é opcional, mas é recomendado usá-lo, caso você não saiba qual linha irá para a entrada.

parsefloat ()

Do exemplo acima, você provavelmente notou que Parseint descarta a parte fracionária. No nosso caso, parsefloat pode trabalhar com números de ponto flutuante. Mais uma vez, pode ser útil ao analisar CSS e outras tarefas, especialmente quando se trabalha com um ponto flutuante em porcentagem.

Sintaxe: parsefloat (string)

Deixe FP \u003d "33.33333%"; Console.log (parsefloat (FP)); \u003e 33.33333.
Por favor, note que não há segundo argumento na sintaxe de parsefloat.

Entendemos que Parseint () e Parsefloat () são recursos extremamente úteis, é importante levar em conta que não é necessário fazer sem erros, por isso é necessário verificar o intervalo de valores esperados e, finalmente, analisar o resultado para garantir que os valores estejam corretos.
Enviar anonimamente