Arredonde para no máximo 2 casas decimais (somente se necessário)

Gostaria de arredondar no máximo duas casas decimais, mas apenas se necessário .

Entrada:

10
1.7777777
9.1

Resultado:

10
1.78
9.1

Como posso fazer isso em JavaScript?

Usar Math.round(num * 100) / 100

Editar: para garantir coisas como 1.005 arredondadas corretamente, usamos

Math.round((num + Number.EPSILON) * 100) / 100

Se o valor for um tipo de texto:

parseFloat("123.456").toFixed(2);

Se o valor for um número:

var numb = 123.23454;
numb = numb.toFixed(2);

Há uma desvantagem de que valores como 1,5 fornecerão "1,50" como saída. Uma correção sugerida por @minitech:

var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.

Parece que Math.roundé uma solução melhor. Mas não é! Em alguns casos, NÃO arredondará corretamente:

Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!

O toFixed () também NÃO será arredondado corretamente em alguns casos (testado no Chrome v.55.0.2883.87)!

Exemplos:

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

Eu acho que isso ocorre porque o 1.555 é na verdade algo como o float 1.55499994 nos bastidores.

A solução 1 é usar um script com o algoritmo de arredondamento necessário, por exemplo:

function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "e-" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
  }
}

https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview

NOTA: Esta não é uma solução universal para todos. Existem vários algoritmos de arredondamento diferentes, sua implementação pode ser diferente, depende de seus requisitos. https://en.wikipedia.org/wiki/Rounding

A solução 2 é evitar cálculos de front-end e extrair valores arredondados do servidor back-end.

Você pode usar

function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}

Eu encontrei isso no MDN . O caminho deles evita o problema com 1.005 mencionado .

roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1
roundToTwo(1234.5678)
1234.57

A resposta de MarkG é a correta. Aqui está uma extensão genérica para qualquer número de casas decimais.

Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "e-" + places);
}

Uso:

var n = 1.7777;    
n.round(2); // 1.78

Teste de unidade:

it.only('should round floats to 2 places', function() {

  var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]

  cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})

Você deveria usar:

Math.round( num * 100 + Number.EPSILON ) / 100

Ninguém parece estar ciente de Number.EPSILON .

Também vale a pena notar que isso não é uma esquisitice do JavaScript, como algumas pessoas declararam.

É assim que os números de ponto flutuante funcionam em um computador. Como 99% das linguagens de programação, o JavaScript não possui números de ponto flutuante caseiros ; depende da CPU / FPU para isso. Um computador usa binário e, em binário, não há números como0.1 , mas uma mera aproximação binária para isso. Por quê? Pela mesma razão que 1/3 não pode ser escrito em decimal: seu valor é 0,33333333 ... com um infinito de três.

Aqui vem Number.EPSILON. Esse número é a diferença entre 1 e o próximo número existente nos números de ponto flutuante de precisão dupla. É isso: não há número entre 1e 1 + Number.EPSILON.

EDITAR:

Conforme solicitado nos comentários, vamos esclarecer uma coisa: adicionar Number.EPSILON é relevante apenas quando o valor a arredondar é o resultado de uma operação aritmética, pois pode engolir algum delta de erro de ponto flutuante.

Não é útil quando o valor vem de uma fonte direta (por exemplo: literal, entrada do usuário ou sensor).

EDIT (2019):

Como o @maganap e algumas pessoas apontaram, é melhor adicionar Number.EPSILONantes de multiplicar:

Math.round( ( num + Number.EPSILON ) * 100 ) / 100

EDIT (dezembro de 2019):

Ultimamente, uso uma função semelhante a esta para comparar números com reconhecimento de epsilon:

const ESPILON_RATE = 1 + Number.EPSILON ;
const ESPILON_ZERO = Number.MIN_VALUE ;

function epsilonEquals( a , b ) {
  if ( Number.isNaN( a ) || Number.isNaN( b ) ) {
    return false ;
  }
  if ( a === 0 || b === 0 ) {
    return a <= b + EPSILON_ZERO && b <= a + EPSILON_ZERO ;
  }
  return a <= b * EPSILON_RATE && b <= a * EPSILON_RATE ;
}

Meu caso de uso é uma afirmação + validação de dados que estou desenvolvendo há muitos anos.

De fato, no código que estou usando ESPILON_RATE = 1 + 4 * Number.EPSILONe EPSILON_ZERO = 4 * Number.MIN_VALUE(quatro vezes o epsilon), porque quero um verificador de igualdade solto o suficiente para acumular erro de ponto flutuante.

Até agora, parece perfeito para mim. Eu espero que isso ajude.

Pode-se usar .toFixed(NumberOfDecimalPlaces).

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

Esta questão é complicada.

Suponha que tenhamos uma função, roundTo2DP(num)que aceita float como argumento e retorna um valor arredondado para 2 casas decimais. O que cada uma dessas expressões deve avaliar?

• roundTo2DP(0.014999999999999999)
• roundTo2DP(0.0150000000000000001)
• roundTo2DP(0.015)

A resposta 'óbvia' é que o primeiro exemplo deve arredondar para 0,01 (porque é mais próximo de 0,01 do que 0,02), enquanto os outros dois devem arredondar para 0,02 (porque 0,01500000000000000000001 está mais próximo de 0,02 do que 0,01 e porque 0,015 está exatamente na metade do caminho eles e existe uma convenção matemática de que esses números são arredondados).

O problema, que você deve ter adivinhado, é que roundTo2DP não pode ser implementado para dar essas respostas óbvias, porque todos os três números passados ​​para ele são o mesmo número . Os números binários de ponto flutuante IEEE 754 (o tipo usado pelo JavaScript) não podem representar exatamente a maioria dos números não inteiros e, portanto, todos os três literais numéricos acima são arredondados para um número de ponto flutuante válido nas proximidades. Esse número, por acaso, é exatamente

0.01499999999999999944488848768742172978818416595458984375

que é mais próximo de 0,01 do que 0,02.

Você pode ver que todos os três números são iguais no console do navegador, no shell do nó ou em outro intérprete JavaScript. Basta compará-los:

> 0.014999999999999999 === 0.0150000000000000001
true

Então, quando escrevo m = 0.0150000000000000001, o valor exato dom qual acabo é mais próximo 0.01do que é 0.02. E, no entanto, se eu converter mpara uma String ...

> var m = 0.0150000000000000001;
> console.log(String(m));
0.015
> var m = 0.014999999999999999;
> console.log(String(m));
0.015

... recebo 0,015, que deve arredondar para 0,02, e que não é notavelmente o número de 56 casas decimais que eu disse anteriormente que todos esses números eram exatamente iguais a. Então, que magia negra é essa?

A resposta pode ser encontrada na especificação ECMAScript, na seção 7.1.12.1: ToString aplicada ao tipo Number . Aqui são estabelecidas as regras para converter algum número m em uma string. A parte da chave é o ponto 5, no qual um número inteiro s é gerado cujos dígitos serão usados ​​na representação String de m :

Seja n , k e s números inteiros tais que k ≥ 1, 10 ^{k -1} ≤ s <10 ^k , o valor numérico para s × 10 ^{n - k} é m , e k é o menor possível. Observe que k é o número de dígitos na representação decimal de s , que s não é divisível por 10 e que o dígito menos significativo de s não é necessariamente determinado exclusivamente por esses critérios.

A parte principal aqui é a exigência de que " k seja o menor possível". O que esse requisito equivale é um requisito que, dado um Número m, o valor de String(m)deve ter o menor número possível de dígitos enquanto ainda satisfaz o requisito que Number(String(m)) === m. Como já sabemos disso 0.015 === 0.0150000000000000001, agora está claro por que String(0.0150000000000000001) === '0.015'deve ser verdade.

Obviamente, nenhuma dessas discussões respondeu diretamente o que roundTo2DP(m) deveria retornar. Se mo valor exato for 0,01499999999999999944488848768742172978818416595458984375, mas sua representação de String for '0,015', qual é a resposta correta - matematicamente, praticamente, filosoficamente ou o que for - quando o arredondamos para duas casas decimais?

Não existe uma resposta correta para isso. Depende do seu caso de uso. Você provavelmente deseja respeitar a representação String e arredondar para cima quando:

• O valor que está sendo representado é inerentemente discreto, por exemplo, uma quantidade de moeda em uma moeda de 3 casas decimais, como dinares. Nesse caso, o valor verdadeiro de um número como 0,015 é 0,015 e a representação 0,0149999999 ... que chega no ponto flutuante binário é um erro de arredondamento. (Obviamente, muitos argumentarão, razoavelmente, que você deve usar uma biblioteca decimal para manipular esses valores e nunca representá-los como números binários de ponto flutuante em primeiro lugar.)
• O valor foi digitado por um usuário. Nesse caso, novamente, o número decimal exato inserido é mais 'verdadeiro' do que a representação binária de ponto flutuante mais próxima.

Por outro lado, você provavelmente quer respeitar o valor do ponto flutuante binário e arredondar para baixo quando o valor for de uma escala inerentemente contínua - por exemplo, se for uma leitura de um sensor.

Essas duas abordagens requerem código diferente. Para respeitar a representação String do número, podemos (com um pouco de código razoavelmente sutil) implementar nosso próprio arredondamento que atua diretamente na representação String, dígito por dígito, usando o mesmo algoritmo que você usaria na escola quando foram ensinados a arredondar números. Abaixo está um exemplo que respeita o requisito do OP de representar o número com 2 casas decimais "somente quando necessário" eliminando os zeros à direita após o ponto decimal; você pode, é claro, precisar ajustá-lo às suas necessidades precisas.

/**
 * Converts num to a decimal string (if it isn't one already) and then rounds it
 * to at most dp decimal places.
 *
 * For explanation of why you'd want to perform rounding operations on a String
 * rather than a Number, see http://stackoverflow.com/a/38676273/1709587
 *
 * @param {(number|string)} num
 * @param {number} dp
 * @return {string}
 */
function roundStringNumberWithoutTrailingZeroes (num, dp) {
    if (arguments.length != 2) throw new Error("2 arguments required");

    num = String(num);
    if (num.indexOf('e+') != -1) {
        // Can't round numbers this large because their string representation
        // contains an exponent, like 9.99e+37
        throw new Error("num too large");
    }
    if (num.indexOf('.') == -1) {
        // Nothing to do
        return num;
    }

    var parts = num.split('.'),
        beforePoint = parts[0],
        afterPoint = parts[1],
        shouldRoundUp = afterPoint[dp] >= 5,
        finalNumber;

    afterPoint = afterPoint.slice(0, dp);
    if (!shouldRoundUp) {
        finalNumber = beforePoint + '.' + afterPoint;
    } else if (/^9+$/.test(afterPoint)) {
        // If we need to round up a number like 1.9999, increment the integer
        // before the decimal point and discard the fractional part.
        finalNumber = Number(beforePoint)+1;
    } else {
        // Starting from the last digit, increment digits until we find one
        // that is not 9, then stop
        var i = dp-1;
        while (true) {
            if (afterPoint[i] == '9') {
                afterPoint = afterPoint.substr(0, i) +
                             '0' +
                             afterPoint.substr(i+1);
                i--;
            } else {
                afterPoint = afterPoint.substr(0, i) +
                             (Number(afterPoint[i]) + 1) +
                             afterPoint.substr(i+1);
                break;
            }
        }

        finalNumber = beforePoint + '.' + afterPoint;
    }

    // Remove trailing zeroes from fractional part before returning
    return finalNumber.replace(/0+$/, '')
}

Exemplo de uso:

> roundStringNumberWithoutTrailingZeroes(1.6, 2)
'1.6'
> roundStringNumberWithoutTrailingZeroes(10000, 2)
'10000'
> roundStringNumberWithoutTrailingZeroes(0.015, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.015000', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(1, 1)
'1'
> roundStringNumberWithoutTrailingZeroes('0.015', 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes(0.01499999999999999944488848768742172978818416595458984375, 2)
'0.02'
> roundStringNumberWithoutTrailingZeroes('0.01499999999999999944488848768742172978818416595458984375', 2)
'0.01'

A função acima é provavelmente o que você deseja usar para evitar que os usuários assistam aos números digitados serem arredondados incorretamente.

(Como alternativa, você também pode tentar o biblioteca round10 , que fornece uma função de comportamento semelhante com uma implementação totalmente diferente.)

Mas e se você tiver o segundo tipo de Número - um valor extraído de uma escala contínua, onde não há razão para pensar que representações decimais aproximadas com menos casas decimais são mais precisas do que aquelas com mais? Nesse caso, nós não queremos respeitar a representação String, porque essa representação (conforme explicado na especificação) já é do tipo arredondada; não queremos cometer o erro de dizer "0,014999999 ... 375 arredonda para 0,015, que arredonda para 0,02, então 0,014999999 ... 375 arredonda para 0,02".

Aqui podemos simplesmente usar o toFixedmétodo embutido . Observe que, chamando Number()a String retornada por toFixed, obtemos um Número cuja representação de String não possui zeros à direita (graças à maneira como o JavaScript calcula a representação de String de um Número, discutida anteriormente nesta resposta).

/**
 * Takes a float and rounds it to at most dp decimal places. For example
 *
 *     roundFloatNumberWithoutTrailingZeroes(1.2345, 3)
 *
 * returns 1.234
 *
 * Note that since this treats the value passed to it as a floating point
 * number, it will have counterintuitive results in some cases. For instance,
 * 
 *     roundFloatNumberWithoutTrailingZeroes(0.015, 2)
 *
 * gives 0.01 where 0.02 might be expected. For an explanation of why, see
 * http://stackoverflow.com/a/38676273/1709587. You may want to consider using the
 * roundStringNumberWithoutTrailingZeroes function there instead.
 *
 * @param {number} num
 * @param {number} dp
 * @return {number}
 */
function roundFloatNumberWithoutTrailingZeroes (num, dp) {
    var numToFixedDp = Number(num).toFixed(dp);
    return Number(numToFixedDp);
}

Considere .toFixed()e .toPrecision():

http://www.javascriptkit.com/javatutors/formatnumber.shtml

Um método de arredondamento preciso. Fonte: Mozilla

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
        // Shift back
        value = value.toString().split('e');
        return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

Exemplos:

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

Nenhuma das respostas encontradas aqui está correta . @stinkycheeseman pediu para arredondar , todos vocês arredondaram o número.

Para arredondar, use o seguinte:

Math.ceil(num * 100)/100;

Aqui está uma maneira simples de fazer isso:

Math.round(value * 100) / 100

Você pode ir em frente e criar uma função separada para fazer isso por você:

function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}

Então você simplesmente passaria o valor.

Você pode aprimorá-lo para arredondar para qualquer número arbitrário de casas decimais adicionando um segundo parâmetro.

function myRound(value, places) {
    var multiplier = Math.pow(10, places);

    return (Math.round(value * multiplier) / multiplier);
}

+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12

(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

Para mim, Math.round () não estava dando a resposta correta. Achei que oFixed (2) funciona melhor. Abaixo estão exemplos de ambos:

console.log(Math.round(43000 / 80000) * 100); // wrong answer

console.log(((43000 / 80000) * 100).toFixed(2)); // correct answer

Use esta função Number(x).toFixed(2);

2017
Basta usar código nativo.toFixed()

number = 1.2345;
number.toFixed(2) // "1.23"

Se você precisar ser rigoroso e adicionar dígitos, se necessário, ele poderá usar replace

number = 1; // "1"
number.toFixed(5).replace(/\.?0*$/g,'');

Experimente esta solução leve :

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}

 round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

Existem algumas maneiras de fazer isso. Para pessoas como eu, a variante do Lodash

function round(number, precision) {
    var pair = (number + 'e').split('e')
    var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
    pair = (value + 'e').split('e')
    return +(pair[0] + 'e' + (+pair[1] - precision))
}

Uso:

round(0.015, 2) // 0.02
round(1.005, 2) // 1.01

Se o seu projeto usa jQuery ou lodash, você também pode encontrar round método nas bibliotecas.

Atualização 1

Eu removi a variante n.toFixed(2), porque não está correta. Obrigado @ avalanche1

Se você estiver usando a biblioteca lodash, poderá usar o método round da lodash como a seguir.

_.round(number, precision)

Por exemplo:

_.round(1.7777777, 2) = 1.78

Desde o ES6, existe uma maneira 'adequada' (sem substituir as estáticas e criar soluções alternativas) para fazer isso usando toPrecision

var x = 1.49999999999;
console.log(x.toPrecision(4));
console.log(x.toPrecision(3));
console.log(x.toPrecision(2));

var y = Math.PI;
console.log(y.toPrecision(6));
console.log(y.toPrecision(5));
console.log(y.toPrecision(4));

var z = 222.987654
console.log(z.toPrecision(6));
console.log(z.toPrecision(5));
console.log(z.toPrecision(4));

então você pode simplesmente parseFloate os zeros 'desaparecem'.

console.log(parseFloat((1.4999).toPrecision(3)));
console.log(parseFloat((1.005).toPrecision(3)));
console.log(parseFloat((1.0051).toPrecision(3)));

No entanto, ele não resolve o 'problema de arredondamento 1.005' - pois é intrínseco ao modo como as frações flutuantes estão sendo processadas .

console.log(1.005 - 0.005);

Se você estiver aberto para bibliotecas, poderá usar o bignumber.js

console.log(1.005 - 0.005);
console.log(new BigNumber(1.005).minus(0.005));

console.log(new BigNumber(1.005).round(4));
console.log(new BigNumber(1.005).round(3));
console.log(new BigNumber(1.005).round(2));
console.log(new BigNumber(1.005).round(1));

<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/2.3.0/bignumber.min.js"></script>

MarkG e Lavamantis ofereceram uma solução muito melhor do que a que foi aceita. É uma pena que eles não recebam mais votos!

Aqui está a função que eu uso para resolver os problemas de decimais de ponto flutuante também baseados no MDN . É ainda mais genérico (mas menos conciso) do que a solução de Lavamantis:

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp  = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}

Use-o com:

round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46

Comparado à solução da Lavamantis, podemos fazer ...

round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

Isso pode ajudá-lo a:

var result = Math.round(input*100)/100;

para mais informações, você pode dar uma olhada neste link

Math.round (num) vs num.toFixed (0) e inconsistências do navegador

A abordagem mais fácil seria usar o toFixed e depois remover zeros à direita usando a função Number:

const number = 15.5;
Number(number.toFixed(2)); // 15.5

const number = 1.7777777;
Number(number.toFixed(2)); // 1.78

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed(2) aqui 2 é o número de dígitos até o qual queremos arredondar esse número.

Pode funcionar para você,

Math.round(num * 100)/100;

saber a diferença entre toFixed e round. Você pode dar uma olhada nas inconsistências Math.round (num) vs num.toFixed (0) e no navegador .

Caminho mais fácil:

+num.toFixed(2)

Ele o converte em uma sequência e depois volta para um número inteiro / float.

Aqui está um método de protótipo:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}

var yournum = 10.55555;
yournum = yournum.round(2);

Use algo parecido com isto "parseFloat (parseFloat (value) .toFixed (2))"

parseFloat(parseFloat("1.7777777").toFixed(2))-->1.78 
parseFloat(parseFloat("10").toFixed(2))-->10 
parseFloat(parseFloat("9.1").toFixed(2))-->9.1

Uma maneira de obter esse arredondamento apenas se necessário é usar Number.prototype.toLocaleString () :

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})

Isso fornecerá exatamente a saída que você espera, mas como strings. Você ainda pode convertê-los novamente em números, se esse não for o tipo de dados que você espera.

Depois de executar várias iterações de todas as formas possíveis para obter uma precisão exata de arredondamento decimal, é claro que a solução mais precisa e eficiente é usar Number.EPSILON. Isso fornece uma verdadeira solução matemática para o problema da precisão matemática de ponto flutuante. Ele pode ser facilmente preenchido como mostrado aqui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON para oferecer suporte a todos os últimos usuários restantes do IE (talvez seja necessário deve parar de fazer isso).

Adaptado da solução fornecida aqui: https://stackoverflow.com/a/48850944/6910392

Uma solução simples que fornece arredondamento decimal preciso, piso e teto, com uma variável de precisão opcional sem adicionar uma biblioteca inteira.

ATUALIZAÇÃO: Como Sergey observou nos comentários, há uma limitação a este (ou a qualquer outro) método que vale a pena ressaltar. No caso de números como 0,014999999999999999, você ainda terá imprecisões que resultam de atingir o limite absoluto das limitações de precisão para armazenamento de valor de ponto flutuante. Não há matemática ou outra solução que possa ser aplicada para explicar isso, pois o valor em si é imediatamente avaliado como 0,015. Você pode confirmar isso simplesmente invocando esse valor sozinho no console. Devido a essa limitação, nem seria possível usar a manipulação de strings para reduzir esse valor, pois sua representação de strings é simplesmente "0,015". Qualquer solução para explicar isso precisaria ser aplicada logicamente na origem dos dados antes de aceitar o valor em um script,

var DecimalPrecision = (function(){
        if (Number.EPSILON === undefined) {
            Number.EPSILON = Math.pow(2, -52);
        }
        this.round = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.round((n + r) * o) / o;
        }
        this.ceil = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.ceil((n + r) * o) / o;
        }
        this.floor = function(n, p=2){
            let r = 0.5 * Number.EPSILON * n;
            let o = 1; while(p-- > 0) o *= 10;
            if(n < 0)
                o *= -1;
            return Math.floor((n + r) * o) / o;
        }
        return this;
    })();
    console.log(DecimalPrecision.round(1.005));
    console.log(DecimalPrecision.ceil(1.005));
    console.log(DecimalPrecision.floor(1.005));
    console.log(DecimalPrecision.round(1.0049999));
    console.log(DecimalPrecision.ceil(1.0049999));
    console.log(DecimalPrecision.floor(1.0049999));
    console.log(DecimalPrecision.round(2.175495134384,7));
    console.log(DecimalPrecision.round(2.1753543549,8));
    console.log(DecimalPrecision.round(2.1755465135353,4));

Essa é a solução mais simples e elegante (e eu sou a melhor do mundo;):

function roundToX(num, X) {    
    return +(Math.round(num + "e+"+X)  + "e-"+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9