Arrondir à au plus 2 décimales (uniquement si nécessaire)

Je voudrais arrondir au plus 2 décimales, mais seulement si nécessaire .

Contribution:

10
1.7777777
9.1

Production:

10
1.78
9.1

Comment faire cela en JavaScript?

Utilisation Math.round(num * 100) / 100

Edit: pour garantir que des choses comme 1,005 arrondissent correctement, nous utilisons

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

Si la valeur est un type de texte:

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

Si la valeur est un nombre:

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

Il y a un inconvénient: des valeurs comme 1,5 donneront "1,50" en sortie. Un correctif suggéré par @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.

Il semble que ce Math.roundsoit une meilleure solution. Mais ce n'est pas! Dans certains cas, il ne sera PAS arrondi correctement:

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

toFixed () ne sera PAS non plus arrondi correctement dans certains cas (testé dans Chrome v.55.0.2883.87)!

Exemples:

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.

Je suppose que c'est parce que 1.555 est en fait quelque chose comme flotteur 1.55499994 dans les coulisses.

La solution 1 consiste à utiliser un script avec l'algorithme d'arrondi requis, par exemple:

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

REMARQUE: ce n'est pas une solution universelle pour tout le monde. Il existe plusieurs algorithmes d'arrondi différents, votre implémentation peut être différente, dépend de vos besoins. https://en.wikipedia.org/wiki/Rounding

La solution 2 consiste à éviter les calculs frontaux et à extraire les valeurs arrondies du serveur principal.

Vous pouvez utiliser

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

J'ai trouvé ça sur MDN . Leur façon d'éviter le problème avec 1.005 qui a été mentionné .

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

La réponse de MarkG est la bonne. Voici une extension générique pour un nombre quelconque de décimales.

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

Usage:

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

Test de l'unité:

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

Tu devrais utiliser:

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

Personne ne semble en être conscient Number.EPSILON.

Il convient également de noter que ce n'est pas une bizarrerie JavaScript comme certaines personnes l'ont déclaré.

C'est simplement la façon dont les nombres à virgule flottante fonctionnent dans un ordinateur. Comme 99% des langages de programmation, JavaScript n'a pas de nombres à virgule flottante faits maison ; il s'appuie sur le CPU / FPU pour cela. Un ordinateur utilise le binaire, et en binaire, il n'y a pas de nombres comme0.1 , mais une simple approximation binaire pour cela. Pourquoi? Pour la même raison que 1/3 ne peut pas être écrit en décimal: sa valeur est 0,33333333 ... avec une infinité de trois.

Voici venir Number.EPSILON. Ce nombre est la différence entre 1 et le nombre suivant existant dans les nombres à virgule flottante double précision. C'est tout: il n'y a pas de nombre entre 1et 1 + Number.EPSILON.

ÉDITER:

Comme demandé dans les commentaires, clarifions une chose: ajouter Number.EPSILON n'est pertinent que lorsque la valeur à arrondir est le résultat d'une opération arithmétique, car elle peut avaler un delta d'erreur en virgule flottante.

Ce n'est pas utile lorsque la valeur provient d'une source directe (par exemple: littéral, entrée utilisateur ou capteur).

EDIT (2019):

Comme @maganap et certains peuples l'ont souligné, il est préférable d'ajouter Number.EPSILONavant de multiplier:

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

EDIT (décembre 2019):

Dernièrement, j'utilise une fonction similaire à celle-ci pour comparer les nombres compatibles avec 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 ;
}

Mon cas d'utilisation est une bibliothèque d'assertion + validation de données que je développe depuis de nombreuses années.

En fait, dans le code que j'utilise ESPILON_RATE = 1 + 4 * Number.EPSILONet EPSILON_ZERO = 4 * Number.MIN_VALUE(quatre fois le epsilon), parce que je veux un vérificateur d'égalité suffisamment lâche pour cumuler les erreurs en virgule flottante.

Jusqu'à présent, cela me semble parfait. J'espère que cela aidera.

On peut utiliser .toFixed(NumberOfDecimalPlaces).

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

Cette question est compliquée.

Supposons que nous ayons une fonction roundTo2DP(num),, qui prend un flottant comme argument et renvoie une valeur arrondie à 2 décimales. Que doit évaluer chacune de ces expressions?

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

La réponse `` évidente '' est que le premier exemple devrait arrondir à 0,01 (car il est plus proche de 0,01 que de 0,02) tandis que les deux autres devraient arrondir à 0,02 (car 0,0150000000000000001 est plus proche de 0,02 que de 0,01, et parce que 0,015 est exactement à mi-chemin entre et il existe une convention mathématique selon laquelle ces nombres sont arrondis).

Le problème, que vous avez peut-être deviné, est qu'il roundTo2DP ne peut pas être mis en œuvre pour donner ces réponses évidentes, car les trois nombres qui lui sont transmis sont le même nombre . Les nombres à virgule flottante binaires IEEE 754 (le type utilisé par JavaScript) ne peuvent pas représenter exactement la plupart des nombres non entiers, et donc les trois littéraux numériques ci-dessus sont arrondis à un nombre à virgule flottante valide proche. Il se trouve que ce nombre est exactement

0,01499999999999999944488848768742172978818416595458984375

qui est plus proche de 0,01 que de 0,02.

Vous pouvez voir que les trois nombres sont les mêmes sur la console de votre navigateur, le shell Node ou tout autre interpréteur JavaScript. Il suffit de les comparer:

> 0.014999999999999999 === 0.0150000000000000001
true

Donc, quand j'écris m = 0.0150000000000000001, la valeur exacte de cem que je me retrouve est plus proche 0.01qu'elle ne l'est 0.02. Et pourtant, si je me convertis men une chaîne ...

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

... J'obtiens 0,015, qui devrait arrondir à 0,02, et qui n'est visiblement pas le nombre à 56 décimales. J'ai dit plus tôt que tous ces nombres étaient exactement égaux. Alors, quelle magie noire est-ce?

La réponse peut être trouvée dans la spécification ECMAScript, dans la section 7.1.12.1: ToString appliquée au type Number . Ici, les règles de conversion d'un nombre m en chaîne sont définies. La partie clé est le point 5, dans lequel un entier s est généré dont les chiffres seront utilisés dans la représentation String de m :

soit n , k et s des entiers tels que k ≥ 1, 10 ^{k -1} ≤ s <10 ^k , la valeur numérique pour s × 10 ^{n - k} est m et k est aussi petit que possible. Notez que k est le nombre de chiffres dans la représentation décimale de s , que s n'est pas divisible par 10 et que le chiffre le moins significatif de s n'est pas nécessairement déterminé de manière unique par ces critères.

L'élément clé ici est l'exigence que " k soit aussi petit que possible". Ce que signifie cette exigence est une exigence selon laquelle, étant donné un nombre m, la valeur de String(m)doit avoir le moins de chiffres possible tout en satisfaisant à l'exigence que Number(String(m)) === m. Puisque nous le savons déjà 0.015 === 0.0150000000000000001, il est maintenant clair pourquoi cela String(0.0150000000000000001) === '0.015'doit être vrai.

Bien sûr, aucune de ces discussions n'a directement répondu à ce qui roundTo2DP(m) devrait revenir. Si mla valeur exacte est 0,01499999999999999944488848768742172978818416595458984375, mais sa représentation de chaîne est '0,015', alors quelle est la bonne réponse - mathématiquement, pratiquement, philosophiquement, ou autre - quand nous l'arrondissons à deux décimales?

Il n'y a pas de réponse correcte unique à cela. Cela dépend de votre cas d'utilisation. Vous voudrez probablement respecter la représentation String et arrondir vers le haut lorsque:

• La valeur représentée est intrinsèquement discrète, par exemple un montant de devise dans une devise à 3 décimales comme les dinars. Dans ce cas, la vraie valeur d'un nombre comme 0,015 est 0,015 et la représentation 0,0149999999 ... qu'il obtient en virgule flottante binaire est une erreur d'arrondi. (Bien sûr, beaucoup diront, raisonnablement, que vous devez utiliser une bibliothèque décimale pour gérer ces valeurs et ne jamais les représenter comme des nombres à virgule flottante binaire en premier lieu.)
• La valeur a été saisie par un utilisateur. Dans ce cas, encore une fois, le nombre décimal exact entré est plus «vrai» que la représentation binaire flottante la plus proche.

D'un autre côté, vous voulez probablement respecter la valeur à virgule flottante binaire et arrondir vers le bas lorsque votre valeur provient d'une échelle intrinsèquement continue - par exemple, s'il s'agit d'une lecture provenant d'un capteur.

Ces deux approches nécessitent un code différent. Pour respecter la représentation String du nombre, nous pouvons (avec un peu de code raisonnablement subtil) implémenter notre propre arrondi qui agit directement sur la représentation String, chiffre par chiffre, en utilisant le même algorithme que vous auriez utilisé à l'école lorsque vous ont appris à arrondir les nombres. Voici un exemple qui respecte l'exigence du PO de représenter le nombre à 2 décimales "uniquement lorsque cela est nécessaire" en supprimant les zéros de fin après la virgule; vous devrez peut-être, bien sûr, l'adapter à vos besoins précis.

/**
 * 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+$/, '')
}

Exemple d'utilisation:

> 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'

La fonction ci-dessus est probablement celle que vous souhaitez utiliser pour éviter que les utilisateurs ne voient jamais les nombres qu'ils ont entrés être arrondis incorrectement.

(Comme alternative, vous pouvez également essayer la bibliothèque round10 qui fournit une fonction similaire avec une implémentation très différente.)

Mais que se passe-t-il si vous avez le deuxième type de nombre - une valeur prise sur une échelle continue, où il n'y a aucune raison de penser que les représentations décimales approximatives avec moins de décimales sont plus précises que celles avec plus? Dans ce cas, nous ne voulons pas respecter la représentation String, car cette représentation (comme expliqué dans la spécification) est déjà en quelque sorte arrondie; nous ne voulons pas faire l'erreur de dire "0,014999999 ... 375 arrondit à 0,015, ce qui arrondit à 0,02, donc 0,014999999 ... 375 arrondit à 0,02".

Ici, nous pouvons simplement utiliser la toFixedméthode intégrée . Notez qu'en appelant Number()la chaîne renvoyée par toFixed, nous obtenons un nombre dont la représentation de chaîne n'a pas de zéros de fin (grâce à la façon dont JavaScript calcule la représentation de chaîne d'un nombre, discutée plus haut dans cette réponse).

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

Considérez .toFixed()et .toPrecision():

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

Une méthode d'arrondi précise. Source: 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);
        };
    }
})();

Exemples:

// 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

Aucune des réponses trouvées ici n'est correcte . @stinkycheeseman a demandé d' arrondir , vous avez tous arrondi le nombre.

Pour arrondir, utilisez ceci:

Math.ceil(num * 100)/100;

Voici un moyen simple de le faire:

Math.round(value * 100) / 100

Vous voudrez peut-être continuer et créer une fonction distincte pour le faire pour vous:

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

Ensuite, vous passeriez simplement la valeur.

Vous pouvez l'améliorer pour arrondir à n'importe quel nombre arbitraire de décimales en ajoutant un deuxième paramètre.

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

Pour moi, Math.round () ne donnait pas la bonne réponse. J'ai trouvé que toFixed (2) fonctionnait mieux. Voici des exemples des deux:

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

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

Utilisez cette fonction Number(x).toFixed(2);

2017
Il suffit d'utiliser du code natif.toFixed()

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

Si vous devez être strict et ajouter des chiffres au besoin, il peut utiliser replace

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

Essayez cette solution légère :

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

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

Il y a plusieurs façons de procéder. Pour les gens comme moi, la variante du 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))
}

Usage:

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

Si votre projet utilise jQuery ou lodash, vous pouvez également trouver round méthode dans les bibliothèques.

Mise à jour 1

J'ai supprimé la variante n.toFixed(2), car elle n'est pas correcte. Merci @ avalanche1

Si vous utilisez la bibliothèque lodash, vous pouvez utiliser la méthode ronde de lodash comme suit.

_.round(number, precision)

Par exemple:

_.round(1.7777777, 2) = 1.78

Depuis ES6, il existe un moyen «approprié» (sans remplacer les statiques et sans créer de solutions de contournement) de le faire en utilisant 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));

alors vous pouvez juste parseFloatet les zéros «disparaîtront».

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

Cela ne résout pas le `` problème d'arrondi 1.005 '', car il est intrinsèque à la façon dont les fractions flottantes sont traitées .

console.log(1.005 - 0.005);

Si vous êtes ouvert aux bibliothèques, vous pouvez utiliser 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 et Lavamantis ont offert une bien meilleure solution que celle qui a été acceptée. C'est dommage qu'ils n'obtiennent pas plus de votes positifs!

Voici la fonction que j'utilise pour résoudre les problèmes de décimales à virgule flottante également basée sur MDN . Elle est encore plus générique (mais moins concise) que la solution 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));
}

Utilisez-le avec:

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

Par rapport à la solution de Lavamantis, nous pouvons faire ...

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

Cela peut vous aider:

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

pour plus d'informations, vous pouvez consulter ce lien

Math.round (num) vs num.toFixed (0) et incohérences du navigateur

L'approche la plus simple serait d'utiliser toFixed puis de supprimer les zéros de fin à l'aide de la fonction 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) ici 2 est le nombre de chiffres jusqu'à ce que nous voulons arrondir ce nombre.

Cela peut fonctionner pour vous,

Math.round(num * 100)/100;

pour connaître la différence entre toFixed et round. Vous pouvez voir Math.round (num) vs num.toFixed (0) et les incohérences du navigateur .

Manière la plus simple:

+num.toFixed(2)

Il le convertit en chaîne, puis de nouveau en entier / flottant.

Voici une méthode prototype:

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

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

Utilisez quelque chose comme ceci "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

Une façon d'obtenir un tel arrondi uniquement si nécessaire est d'utiliser Number.prototype.toLocaleString () :

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

Cela fournira exactement la sortie que vous attendez, mais sous forme de chaînes. Vous pouvez toujours les reconvertir en nombres si ce n'est pas le type de données que vous attendez.

Après avoir parcouru diverses itérations de toutes les manières possibles d'obtenir une précision d'arrondi décimale vraie et précise, il est clair que la solution la plus précise et la plus efficace consiste à utiliser Number.EPSILON. Cela fournit une véritable solution mathématique au problème de la précision mathématique à virgule flottante. Il peut être facilement polyfilled comme indiqué ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON pour prendre en charge tous les derniers utilisateurs IE restants (là encore, peut-être que nous devrait cesser de le faire).

Adapté de la solution fournie ici: https://stackoverflow.com/a/48850944/6910392

Une solution simple qui fournit un arrondi décimal, un sol et un plafond précis, avec une variable de précision en option sans ajouter une bibliothèque entière.

MISE À JOUR: Comme Sergey l'a noté dans les commentaires, il y a une limitation à cette (ou toute) méthode qui mérite d'être signalée. Dans le cas de nombres comme 0,01499999999999999999, vous rencontrerez toujours des inexactitudes qui sont le résultat de l'atteinte du bord absolu des limitations de précision pour le stockage de valeurs à virgule flottante. Il n'y a pas de solution mathématique ou autre qui peut être appliquée pour expliquer cela, car la valeur elle-même est immédiatement évaluée à 0,015. Vous pouvez le confirmer en invoquant simplement cette valeur par elle-même dans la console. En raison de cette limitation, il ne serait même pas possible d'utiliser la manipulation de chaîne pour réduire cette valeur, car sa représentation sous forme de chaîne est simplement "0,015". Toute solution pour en tenir compte devrait être appliquée logiquement à la source des données avant d'accepter la valeur dans un 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));

C'est la solution la plus simple et la plus élégante (et je suis le meilleur du monde;):

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