Arredondamento de Javascript para o número inteiro mais próximo. Objeto matemático em javascript - Métodos Round, ceil e floor - Arredondamento de números fracionários

25.11.2023

Freqüentemente, o resultado dos cálculos é um número com um grande número de casas decimais. Se esse número for usado para cálculos adicionais, ele poderá ser deixado como está. Mas às vezes um número precisa ser arredondado, por exemplo, para exibição em uma página. JavaScript arredonda números usando vários métodos.

O método Math.round() arredonda o valor para um número inteiro.

Math.round (número)

Os números são arredondados de acordo com regras matemáticas. Ou seja, se após a vírgula houver um número de 0 a 4, a parte fracionária é simplesmente descartada. E se após a vírgula houver um número de 5 a 9, então a parte fracionária é descartada e um é adicionado à parte inteira. exemplo:

JavaScript:

Existem mais dois métodos que arredondam um número para um número inteiro. O método Math.floor() arredonda para baixo. Ele descarta a parte fracionária do número. E o método Math.ceil() completa. Ele descarta a parte fracionária e adiciona um à parte inteira. Exemplo:

Claro, 5 - (-2) é 5+2. Não se esqueça de que você não obterá o número 5 nesta fórmula. O máximo será 4,999999999. Os valores resultantes podem ser arredondados para a precisão necessária.

Se apenas números inteiros forem necessários, os valores resultantes poderão ser arredondados para o número inteiro mais próximo. Deve-se somar ao máximo para que esse máximo também seja possível. A fórmula fica assim:

inteiro = Math.floor(min + Math.random() * (máx. + 1 - min)

Vamos imprimir números de 10 a 15:

20
21
22
23
24

para (i=1; i= (maior ou igual a), 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

Erros ocorrem porque todos os cálculos são feitos por computador ou outro dispositivo eletrônico produz no sistema de 2 números. 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 em sistema binário convertido exatamente.

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).

Muitas vezes, os cálculos em JavaScript não fornecem exatamente os resultados que desejamos. Claro, podemos fazer o que quisermos com os números - arredondar para cima ou para baixo, definir intervalos, cortar números desnecessários para um certo número de casas decimais, tudo depende do que você deseja fazer com esse número no futuro.

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Por que o arredondamento é necessário?

Um dos aspectos interessantes do JavaScript é que ele na verdade não armazena números inteiros, trabalhamos imediatamente com números de ponto flutuante. Isso, combinado com o fato de que muitos valores fracionários não podem ser expressos em um número finito de casas decimais, em JavaScript podemos obter resultados como este:

Para efeitos práticos, esta imprecisão não importa em nada, no nosso caso estamos falando de um erro de quintilionésimos, 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. Arredondando Decimais Para cortar um decimal, use toFixed ou o método toPrecision. Ambos tomam um único argumento, que determina, respectivamente, quantos

algarismos significativos (ou seja, o número total de dígitos usados no número) ou casas decimais (o número após a vírgula) devem incluir o resultado: Se um argumento não for definido para toFixed() então o padrão será

igual a zero

, o que significa 0 casas decimais, o argumento terá um valor máximo de 20.
Se nenhum argumento for fornecido para toPrecision, o número permanecerá inalterado

deixe RandNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" NumRando = 87,335; RandNum.toFixed(2); > "87,33" NumRando = 87,337; randNum.toPrecision(3); > "87,3"
Os métodos toFixed() e toPrecision() retornam uma representação em string do resultado, não um número. Isso significa que ao somar um valor arredondado com randNum, produzirá uma concatenação de strings em vez de uma soma de números: Seja RandNum = 6,25; deixe arredondado = randNum.toFixed(); // "6" console.log(randNum + arredondado); > "6.256" data, então você precisará aplicar 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 Em alguns casos, toFixed e toPrecision arredondam o valor 5 para baixo e para cima:

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 de máquina Um método alternativo para arredondar números decimais foi introduzido no ES6. O arredondamento épsilon da máquina 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
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 Todos os métodos apresentados acima podem arredondar para números decimais. Para simplesmente reduzir um número com duas casas decimais, você deve primeiro multiplicá-lo por 100 e depois dividir o resultado resultante por 100:

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

Arredondando para o número mais próximo Para arredondar um número decimal para o número mais próximo, para cima ou para baixo, o que estiver mais próximo, use Math.round():

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.

Arredondando para o número inteiro mais próximo Se você quiser sempre arredondar para baixo, use Math.floor:

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.

Arredondando para o número inteiro mais próximo Por outro lado, se você sempre precisar arredondar, use Math.ceil. Novamente, lembre-se do elevador infinito: Math.ceil sempre irá “subir”, independentemente de o número ser negativo ou não:

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 Se quisermos arredondar para o múltiplo de 5 mais próximo, a maneira mais fácil é criar uma função que divida o número por 5, arredondando-o e depois multiplicando-o pelo mesmo valor:

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 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 Há muitos casos em que queremos obter um valor de x que esteja dentro de um intervalo. Por exemplo, podemos precisar de um valor entre 1 e 100, mas acabamos com um valor de 123. Para corrigir isso, podemos usar min (retorna o menor de um conjunto de números) e max (retorna o maior de qualquer conjunto de números). Em nosso exemplo, o intervalo é de 1 a 100:

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 O arredondamento gaussiano, também conhecido como arredondamento de banqueiro, é onde o arredondamento neste caso ocorre para o número par mais próximo. Este método de arredondamento funciona sem erros estatísticos. A melhor solução foi sugerido por Tim Down:

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.

Ordenação Muitas vezes precisamos ordenar alguns elementos, por exemplo, temos um array de registros de jogos, e eles devem ser organizados em ordem decrescente de classificação do jogador. Infelizmente, método padrão sort() tem algumas limitações surpreendentes: funciona bem com palavras comuns em inglês, mas falha imediatamente quando encontra números, caracteres únicos ou palavras maiúsculas. Classificando alfabeticamente Parece que classificar um array em ordem alfabética deveria ser uma tarefa simples:

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 é um código único para qualquer caractere, independentemente da plataforma, do programa, 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 maiúsculas e minúsculas, precisamos converter todos os elementos temporariamente para minúsculas ou definir nossa 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 Tudo isso não se aplica ao exemplo de que falamos acima sobre a matriz de registros do jogo. Com algumas matrizes numéricas, a classificação funciona perfeitamente, mas em algum momento o resultado pode ser imprevisível:

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.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 Finalmente, se tivermos uma estrutura de dados semelhante a JSON representada como uma matriz de registros de jogo:

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 A exponenciação é uma operação originalmente definida como o resultado da multiplicação repetida de um número natural por ele mesmo, a raiz quadrada de a é o número que dá a quando elevado ao quadrado; Poderíamos usar essas funções constantemente no dia a dia nas aulas de matemática, inclusive no cálculo de áreas, volumes ou mesmo na modelagem física.

Em JavaScript, a função power é representada como Math.pow(), no novo padrão ES7 ela foi introduzida novo operador exponenciação - " * * ".

Elevando a uma potência Para elevar um número à enésima potência, use a função Math.pow(), onde o primeiro argumento é o número que será elevado à potência, o segundo argumento é o expoente:

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 em diversas 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 o oposto de Math.pow(). Como lembramos, a raiz quadrada de a é o número que dá a quando elevado ao quadrado.

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 Claro, podemos usar valores não inteiros em uma destas funções:

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 Trabalhar com matemática em JavaScript é facilitado por uma série de constantes integradas. Essas constantes são propriedades do objeto Math. É importante notar que as constantes são escritas em letras maiúsculas, não em notação CamelCase. Math.abs, parseInt, parseFloat Trabalhar com números em JavaScript pode ser muito mais complicado do que parece. Os valores obtidos nem sempre estão dentro dos limites esperados; às vezes, o resultado pode não ser o que esperávamos. Math.abs() O método Math.abs() retorna o valor absoluto de um número, o que nos lembra uma função matemática semelhante para o módulo de um número.

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

parseInt() Sabemos que JavaScript entende que “15” é uma string, não um número, e, por exemplo, ao analisar propriedades CSS usando JavaScript, ou receber qualquer valor de um array despreparado, nossos resultados podem ser imprevisíveis. Poderíamos receber uma string representada como “17px” como entrada, e isso não é incomum para nós. A questão é como converter essa string em um valor real e usá-la em cálculos posteriores.

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 número decimal, 8 - octal, 16 - 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 usadas 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.

parseFloat() No exemplo acima, você provavelmente notou que parseInt descarta a parte fracionária. No nosso caso, parseFloat pode funcionar com números de ponto flutuante. Novamente, isso pode ser útil ao analisar CSS e outras tarefas, especialmente ao trabalhar com porcentagens de ponto flutuante.

Sintaxe: parseFloat(string)

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

Embora entendamos que parseInt() e parseFloat() são funções extremamente úteis, é importante ter em mente que elas não estão isentas de erros, por isso é necessário verificar o intervalo de valores esperados e, por fim, analisar o resultado para garantir que os valores obtidos estão corretos.
Enviar anonimamente