Format du nombre pour toujours afficher 2 décimales

Je souhaite formater mes chiffres pour toujours afficher 2 décimales, en arrondissant le cas échéant.

Exemples:

number     display
------     -------
1          1.00
1.341      1.34
1.345      1.35

J'utilise ceci:

parseFloat(num).toFixed(2);

Mais il s'affiche 1comme 1plutôt que 1.00.

(Math.round(num * 100) / 100).toFixed(2);

Démo en direct

var num1 = "1";
document.getElementById('num1').innerHTML = (Math.round(num1 * 100) / 100).toFixed(2);

var num2 = "1.341";
document.getElementById('num2').innerHTML = (Math.round(num2 * 100) / 100).toFixed(2);

var num3 = "1.345";
document.getElementById('num3').innerHTML = (Math.round(num3 * 100) / 100).toFixed(2);

span {
    border: 1px solid #000;
    margin: 5px;
    padding: 5px;
}

<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>

Notez qu'il arrondira à 2 décimales, donc l'entrée 1.346reviendra 1.35.

Number(1).toFixed(2);         // 1.00
Number(1.341).toFixed(2);     // 1.34
Number(1.345).toFixed(2);     // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35

document.getElementById('line1').innerHTML = Number(1).toFixed(2);
document.getElementById('line2').innerHTML = Number(1.341).toFixed(2);
document.getElementById('line3').innerHTML = Number(1.345).toFixed(2);
document.getElementById('line4').innerHTML = Number(1.3450001).toFixed(2);

<span id="line1"></span>
<br/>
<span id="line2"></span>
<br/>
<span id="line3"></span>
<br/>
<span id="line4"></span>

Cette réponse échouera si value = 1.005.

Comme meilleure solution, le problème d'arrondi peut être évité en utilisant des nombres représentés en notation exponentielle:

Number(Math.round(1.005+'e2')+'e-2'); // 1.01

Code plus propre comme suggéré par @Kon, et l'auteur original:

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces)

Vous pouvez ajouter toFixed()à la fin pour conserver le point décimal, par exemple: 1.00mais notez qu'il reviendra sous forme de chaîne.

Number(Math.round(parseFloat(value + 'e' + decimalPlaces)) + 'e-' + decimalPlaces).toFixed(decimalPlaces)

Crédit: Arrondir les décimales en JavaScript

var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120

Pour l'arrondi le plus précis, créez cette fonction:

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

et l'utiliser pour arrondir à 2 décimales:

console.log("seeked to " + round(1.005, 2));
> 1.01

Merci à Razu , cet article et la référence Math.round de MDN .

Pour les navigateurs modernes, utilisez toLocaleString:

var num = 1.345;
num.toLocaleString(undefined, { maximumFractionDigits: 2, minimumFractionDigits: 2 });

Spécifiez une balise locale comme premier paramètre pour contrôler le séparateur décimal . Pour un point, utilisez par exemple les paramètres régionaux anglais des États-Unis:

num.toLocaleString("en-US", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

qui donne:

1,35

La plupart des pays européens utilisent une virgule comme séparateur décimal, donc si vous utilisez par exemple les paramètres régionaux suédois / suédois:

num.toLocaleString("sv-SE", { maximumFractionDigits: 2, minimumFractionDigits: 2 });

cela donnera:

1,35

Réponse la plus simple:

var num = 1.2353453;
num.toFixed(2); // 1.24

Exemple: http://jsfiddle.net/E2XU7/

Une solution beaucoup plus générique pour arrondir à N endroits

function roundN(num,n){
  return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}


console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))

Output

1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346

var number = 123456.789;


console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Si vous utilisez déjà jQuery, vous pouvez envisager d'utiliser le plugin jQuery Number Format .

Le plugin peut renvoyer des nombres formatés sous forme de chaîne, vous pouvez définir des séparateurs décimaux et des milliers, et vous pouvez choisir le nombre de décimales à afficher.

$.number( 123, 2 ); // Returns '123.00'

Vous pouvez également obtenir le format de nombre jQuery à partir de GitHub .

C'est ce que tu veux dire?

function showAsFloat(num, n){
      return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}

document.querySelector('#result').textContent = 
    [
     'command                      | result',
     '-----------------------------------------------',
     'showAsFloat(1);              | ' + showAsFloat(1),
     'showAsFloat(1.314);          | ' + showAsFloat(1.314),
     'showAsFloat(\'notanumber\')    | ' + showAsFloat('notanumber'),
     'showAsFloat(\'23.44567\', 3)   | ' + showAsFloat('23.44567', 3),
     'showAsFloat(2456198, 5)      | ' + showAsFloat('2456198', 5),
     'showAsFloat(0);              | ' + showAsFloat(0)
    ].join('\n');

<pre id="result"></pre>

Convertissez un nombre en chaîne, en ne conservant que deux décimales:

var num = 5.56789;
var n = num.toFixed(2);

Le résultat de n sera:

5.57

Cherchez-vous un sol?

var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00

function currencyFormat (num) {
    return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

console.info(currencyFormat(2665));   // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00

Voici également une fonction générique qui peut mettre en forme n'importe quel nombre de décimales:

function numberFormat(val, decimalPlaces) {

    var multiplier = Math.pow(10, decimalPlaces);
    return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}

Lorsqu'un formatage spécifique est requis, vous devez écrire votre propre routine ou utiliser une fonction de bibliothèque qui fait ce dont vous avez besoin. La fonctionnalité de base ECMAScript est généralement insuffisante pour afficher des nombres formatés.

Une explication approfondie de l'arrondi et du formatage est disponible ici: http://www.merlyn.demon.co.uk/js-round.htm#RiJ

En règle générale, l'arrondi et la mise en forme ne doivent être effectués qu'en dernière étape avant la sortie. Cela peut entraîner des erreurs inattendues et détruire la mise en forme.

Il suffit de courir dans celui-ci du fil le plus long, voici ma solution:

parseFloat(Math.round((parseFloat(num * 100)).toFixed(2)) / 100 ).toFixed(2)

Faites-moi savoir si quelqu'un peut percer un trou

Vous ne nous donnez pas l'image complète.

javascript:alert(parseFloat(1).toFixed(2))affiche 1,00 dans mes navigateurs lorsque je le colle dans la barre d’emplacement. Cependant, si vous lui faites quelque chose par la suite, il reviendra.

var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)


shows 1 and not 1.00

var quantity = 12;

var import1 = 12.55;

var total = quantity * import1;

var answer = parseFloat(total).toFixed(2);

document.write(answer);

J'ai dû choisir entre les conversions parseFloat () et Number () avant de pouvoir appeler toFixed (). Voici un exemple d'une entrée utilisateur de mise en forme numérique post-capture.

HTML:

<input type="number" class="dec-number" min="0" step="0.01" />

Gestionnaire d'événements:

$('.dec-number').on('change', function () {
     const value = $(this).val();
     $(this).val(value.toFixed(2));
});

Le code ci-dessus entraînera une exception TypeError. Notez que bien que le type d'entrée html soit "nombre", l'entrée utilisateur est en fait un type de données "chaîne". Cependant, la fonction toFixed () ne peut être invoquée que sur un objet qui est un nombre.

Mon code final ressemblerait à ceci:

$('.dec-number').on('change', function () {
     const value = Number($(this).val());
     $(this).val(value.toFixed(2));
});

La raison pour laquelle je préfère lancer avec Number () vs parseFloat () est parce que je n'ai pas à effectuer de validation supplémentaire ni pour une chaîne d'entrée vide, ni pour la valeur NaN. La fonction Number () gérerait automatiquement une chaîne vide et la convertirait à zéro.

J'aime:

var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75

Arrondissez le nombre avec 2 décimales, puis assurez-vous de l'analyser avec parseFloat() pour renvoyer Number, pas String, sauf si vous ne vous souciez pas s'il s'agit de String ou Number.

Étendre un objet Math avec une méthode de précision

Object.defineProperty(Math, 'precision',{
   value: function (value,precision,type){
             var v = parseFloat(value),
                 p = Math.max(precision,0)||0,
                 t = type||'round';
              return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
          }
    });

console.log(
    Math.precision(3.1,3), // round 3 digits 
    Math.precision(0.12345,2,'ceil'), // ceil 2 digits
    Math.precision(1.1) // integer part
)

parseInt(number * 100) / 100; travaillé pour moi.

voici une autre solution pour arrondir uniquement en utilisant le plancher, ce qui signifie que le montant calculé ne sera pas supérieur au montant d'origine (parfois nécessaire pour les transactions):

Math.floor(num* 100 )/100;

Vous pouvez essayer ce code:

    function FormatNumber(number, numberOfDigits = 2) {
        try {
            return new Intl.NumberFormat('en-US').format(parseFloat(number).toFixed(2));
        } catch (error) {
            return 0;
        }
    }

    var test1 = FormatNumber('1000000.4444');
    alert(test1); // 1,000,000.44

    var test2 = FormatNumber(100000000000.55555555, 4);
    alert(test2); // 100,000,000,000.56

Essayez le code ci-dessous:

function numberWithCommas(number) { 

   var newval = parseFloat(Math.round(number * 100) / 100).toFixed(2);

   return newval.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")

Voici comment je résous mon problème:

parseFloat(parseFloat(floatString).toFixed(2));