Javascript: formatage d'un nombre arrondi à N décimales

en JavaScript, la manière typique d'arrondir un nombre à N décimales est quelque chose comme:

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

Cependant, cette approche arrondira à un maximum de N décimales alors que je veux toujours arrondir à N décimales. Par exemple, «2,0» serait arrondi à «2».

Des idées?

Ce n'est pas un problème d'arrondi, c'est un problème d'affichage. Un nombre ne contient pas d'informations sur les chiffres significatifs; la valeur 2 est la même que 2.0000000000000. C'est lorsque vous transformez la valeur arrondie en une chaîne que vous lui faites afficher un certain nombre de chiffres.

Vous pouvez simplement ajouter des zéros après le nombre, quelque chose comme:

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

(Notez que cela suppose que les paramètres régionaux du client utilisent le point comme séparateur décimal, le code a besoin de plus de travail pour fonctionner pour d'autres paramètres.)

Je pense qu'il y a une approche plus simple à tout donné ici, et c'est la méthode Number.toFixed()déjà implémentée en JavaScript.

écrivez simplement:

var myNumber = 2;

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

etc...

J'ai trouvé un moyen. Voici le code de Christoph avec un correctif:

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;
}

Lisez les détails de la répétition d'un caractère en utilisant un constructeur de tableau ici si vous êtes curieux de savoir pourquoi j'ai ajouté le "+ 1".

Il y a toujours une meilleure façon de faire les choses.

var number = 51.93999999999761;

Je voudrais obtenir une précision à quatre chiffres: 51,94

fais juste:

number.toPrecision(4);

le résultat sera: 51,94

Méthode d'arrondi de type PHP

Le code ci-dessous peut être utilisé pour ajouter votre propre version de Math.round à votre propre espace de noms qui prend un paramètre de précision. Contrairement à l'arrondi décimal dans l'exemple ci-dessus, cela n'effectue aucune conversion vers et à partir de chaînes, et le paramètre de précision fonctionne de la même manière que PHP et Excel où un 1 positif arrondirait à 1 décimale et -1 arrondirait aux dizaines.

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

à partir de la référence Mozilla Developer pour Math.round ()

J'espère que le code fonctionne (n'a pas fait beaucoup de tests):

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;
}

Je pense que la fonction ci-dessous peut aider

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));
}

utilisation: roundOff(600.23458,2);retournera600.23

Cela fonctionne pour arrondir à N chiffres (si vous voulez simplement tronquer à N chiffres, supprimez l'appel Math.round et utilisez celui Math.trunc):

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

J'ai dû recourir à une telle logique à Java dans le passé lorsque je créais des composants E-Slate de manipulation de données . C'est depuis que j'ai découvert qu'en ajoutant 0,1 plusieurs fois à 0, vous vous retrouveriez avec une partie décimale étonnamment longue (cela est dû à l'arithmétique en virgule flottante).

Un commentaire utilisateur au format numéro pour toujours afficher 2 décimales appelle cette technique de mise à l'échelle.

Certains mentionnent qu'il y a des cas qui ne sont pas arrondis comme prévu et à http://www.jacklmoore.com/notes/rounding-in-javascript/, c'est suggéré à la place:

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

Si vous ne vous souciez pas vraiment de l'arrondi, ajoutez simplement un toFixed (x), puis supprimez les 0 de fin et le point si nécessaire. Ce n'est pas une solution rapide.

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;
}