Javascript: formatação de um número arredondado para N decimais

em JavaScript, a maneira típica de arredondar um número para N casas decimais é algo como:

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

function roundNumber(num, dec) {
  return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
}

console.log(roundNumber(0.1 + 0.2, 2));
console.log(roundNumber(2.1234, 2));

No entanto, essa abordagem arredondará para um máximo de N casas decimais, enquanto eu quero sempre arredondar para N casas decimais. Por exemplo, "2.0" seria arredondado para "2".

Alguma ideia?

Isso não é um problema de arredondamento, é um problema de exibição. Um número não contém informações sobre dígitos significativos; o valor 2 é igual a 2.0000000000000. É quando você transforma o valor arredondado em uma string que você o faz exibir um certo número de dígitos.

Você pode simplesmente adicionar zeros após o número, algo como:

var s = number.toString();
if (s.indexOf('.') == -1) s += '.';
while (s.length < s.indexOf('.') + 4) s += '0';

(Observe que isso pressupõe que as configurações regionais do cliente usam o ponto como separador decimal, o código precisa de mais trabalho para funcionar para outras configurações.)

Eu acho que há uma abordagem mais simples para todos dados aqui, e é o método Number.toFixed()já implementado em JavaScript.

simplesmente escreva:

var myNumber = 2;

myNumber.toFixed(2); //returns "2.00"
myNumber.toFixed(1); //returns "2.0"

etc ...

Eu encontrei um caminho. Este é o código de Christoph com uma correção:

function toFixed(value, precision) {
    var precision = precision || 0,
        power = Math.pow(10, precision),
        absValue = Math.abs(Math.round(value * power)),
        result = (value < 0 ? '-' : '') + String(Math.floor(absValue / power));

    if (precision > 0) {
        var fraction = String(absValue % power),
            padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');
        result += '.' + padding + fraction;
    }
    return result;
}

Leia os detalhes de repetição de um caractere usando um construtor de array aqui se você estiver curioso para saber por que adicionei o "+ 1".

Sempre há uma maneira melhor de fazer as coisas.

var number = 51.93999999999761;

Eu gostaria de obter uma precisão de quatro dígitos: 51,94

apenas faça:

number.toPrecision(4);

o resultado será: 51,94

Método de arredondamento semelhante ao PHP

O código a seguir pode ser usado para adicionar sua própria versão de Math.round ao seu próprio namespace, que recebe um parâmetro de precisão. Ao contrário do arredondamento decimal no exemplo acima, ele não executa nenhuma conversão de e para strings, e o parâmetro de precisão funciona da mesma maneira que PHP e Excel, em que um 1 positivo seria arredondado para 1 casa decimal e -1 seria arredondado para dezenas.

var myNamespace = {};
myNamespace.round = function(number, precision) {
    var factor = Math.pow(10, precision);
    var tempNumber = number * factor;
    var roundedTempNumber = Math.round(tempNumber);
    return roundedTempNumber / factor;
};

myNamespace.round(1234.5678, 1); // 1234.6
myNamespace.round(1234.5678, -1); // 1230

da referência do desenvolvedor Mozilla para Math.round ()

Esperançosamente código funcionando (não fiz muitos testes):

function toFixed(value, precision) {
    var precision = precision || 0,
        neg = value < 0,
        power = Math.pow(10, precision),
        value = Math.round(value * power),
        integral = String((neg ? Math.ceil : Math.floor)(value / power)),
        fraction = String((neg ? -value : value) % power),
        padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0');

    return precision ? integral + '.' +  padding + fraction : integral;
}

Acho que a função abaixo pode ajudar

function roundOff(value,round) {
   return (parseInt(value * (10 ** (round + 1))) - parseInt(value * (10 ** round)) * 10) > 4 ? (((parseFloat(parseInt((value + parseFloat(1 / (10 ** round))) * (10 ** round))))) / (10 ** round)) : (parseFloat(parseInt(value * (10 ** round))) / ( 10 ** round));
}

uso: roundOff(600.23458,2);irá retornar600.23

Isso funciona para arredondar para N dígitos (se você deseja apenas truncar para N dígitos, remova a chamada Math.round e use a chamada Math.trunc):

function roundN(value, digits) {
   var tenToN = 10 ** digits;
   return /*Math.trunc*/(Math.round(value * tenToN)) / tenToN;
}

Tive que recorrer a essa lógica em Java no passado, quando eu estava criando componentes E-Slate de manipulação de dados . Isso porque eu descobri que adicionar 0,1 muitas vezes a 0 você acabaria com alguma parte decimal inesperadamente longa (isso se deve à aritmética de ponto flutuante).

Um comentário do usuário em Formato número para sempre mostrar 2 casas decimais chama essa técnica de escalonamento.

Alguns mencionam que há casos que não são arredondados conforme o esperado e em http://www.jacklmoore.com/notes/rounding-in-javascript/ isso é sugerido:

function round(value, decimals) {
  return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

Se você realmente não se importa com o arredondamento, basta adicionar um toFixed (x) e remover os 0es finais e o ponto, se necessário. Não é uma solução rápida.

function format(value, decimals) {
    if (value) {
        value = value.toFixed(decimals);            
    } else {
        value = "0";
    }
    if (value.indexOf(".") < 0) { value += "."; }
    var dotIdx = value.indexOf(".");
    while (value.length - dotIdx <= decimals) { value += "0"; } // add 0's

    return value;
}