Comment puis-je formater des nombres en dollars en chaîne de devises en JavaScript?

Je souhaite formater un prix en JavaScript.
Je voudrais une fonction qui prend un float comme argument et renvoie une string formatée comme ceci:

 "$ 2,500.00" 

Quelle est la meilleure façon de le faire?

30 Solutions collect form web for “Comment puis-je formater des nombres en dollars en chaîne de devises en JavaScript?”

Vous pouvez utiliser:

  var profits=2489.8237 profits.toFixed(3) //returns 2489.824 (round up) profits.toFixed(2) //returns 2489.82 profits.toFixed(7) //returns 2489.8237000 (padding) 

Ensuite, vous pouvez ajouter le signe de '$'.

Si vous avez besoin de ',' pour mille, vous pouvez utiliser:

 Number.prototype.formatMoney = function(c, d, t){ var n = this, c = isNaN(c = Math.abs(c)) ? 2 : c, d = d == undefined ? "." : d, t = t == undefined ? "," : t, s = n < 0 ? "-" : "", i = String(parseInt(n = Math.abs(Number(n) || 0).toFixed(c))), j = (j = i.length) > 3 ? j % 3 : 0; return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : ""); }; 

Et utilisez-le avec:

 (123456789.12345).formatMoney(2, '.', ','); 

Si vous allez toujours utiliser '.' Et ',', vous pouvez les laisser hors de votre appel de méthode, et la méthode sera par défaut pour vous.

 (123456789.12345).formatMoney(2); 

Si votre culture a les deux symboles renversés (c'est-à-dire les Européens), collez simplement les deux lignes suivantes dans la méthode formatMoney :

  d = d == undefined ? "," : d, t = t == undefined ? "." : t, 

Solution courte n ° 1:

 n.toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, '$1,'); 

Solution courte n ° 2:

 n.toFixed(2).replace(/./g, function(c, i, a) { return i && c !== "." && ((a.length - i) % 3 === 0) ? ',' + c : c; }); 

ESSAIS:

 1 --> "1.00" 12 --> "12.00" 123 --> "123.00" 1234 --> "1,234.00" 12345 --> "12,345.00" 123456 --> "123,456.00" 1234567 --> "1,234,567.00" 12345.67 --> "12,345.67" 

DEMO: http://jsfiddle.net/hAfMM/


Solution étendue:

Vous pouvez également étendre le prototype de l'objet Number pour ajouter un support supplémentaire de n'importe quel nombre de décimales [0 .. n] et la taille des groupes de nombres [0 .. x] :

 /** * Number.prototype.format(n, x) * * @param integer n: length of decimal * @param integer x: length of sections */ Number.prototype.format = function(n, x) { var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\.' : '$') + ')'; return this.toFixed(Math.max(0, ~~n)).replace(new RegExp(re, 'g'), '$&,'); }; 1234..format(); // "1,234" 12345..format(2); // "12,345.00" 123456.7.format(3, 2); // "12,34,56.700" 123456.789.format(2, 4); // "12,3456.79" 

DEMO / TESTS: http://jsfiddle.net/hAfMM/435/


Super solution étendue:

Dans cette version super étendue, vous pouvez définir différents types de délimiteurs:

 /** * Number.prototype.format(n, x, s, c) * * @param integer n: length of decimal * @param integer x: length of whole part * @param mixed s: sections delimiter * @param mixed c: decimal delimiter */ Number.prototype.format = function(n, x, s, c) { var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\D' : '$') + ')', num = this.toFixed(Math.max(0, ~~n)); return (c ? num.replace('.', c) : num).replace(new RegExp(re, 'g'), '$&' + (s || ',')); }; 12345678.9.format(2, 3, '.', ','); // "12.345.678,90" 123456.789.format(4, 4, ' ', ':'); // "12 3456:7890" 12345678.9.format(0, 3, '-'); // "12-345-679" 

DEMO / TESTS: http://jsfiddle.net/hAfMM/612/

Intl.numberformat

Javascript a un formatateur de nombre, et il fait partie de l'API d'internationalisation.

 // Create our number formatter. var formatter = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD', minimumFractionDigits: 2, // the default value for minimumFractionDigits depends on the currency // and is usually already 2 }); formatter.format(2500); /* $2,500.00 */ 

JS violon

Quelques notes sur le support du navigateur

  • Tous les principaux navigateurs le supportent aujourd'hui
  • Certains navigateurs mobiles moins connus, comme UC Browser et Opera Mini, ne le supportent pas
  • Mobile FF le prend en charge depuis v56 (actuellement bêta)
  • Il existe une cale pour le supporter sur les anciens navigateurs
  • Regardez CanIUse pour plus d'informations

Intl.NumberFormat vs Number.prototype.toLocaleString

Une note finale comparant cela à l'ancien. toLocaleString . Ils offrent tous deux la même fonctionnalité. Cependant, toLocaleString dans ses anciennes incarnations (pré-Intl) ne prend pas en charge les paramètres régionaux : il utilise les paramètres régionaux du système. Par conséquent, pour être sûr d'utiliser la version correcte, MDN suggère de vérifier l'existence d' Intl . Donc, si vous devez vérifier pour Intl de toute façon, pourquoi ne pas l'utiliser à la place? Toutefois, si vous choisissez d'utiliser la cale, cela permet également de toLocaleString , alors, dans ce cas, vous pouvez l'utiliser sans tracas:

 (2500).toLocaleString('en-US', { style: 'currency', currency: 'USD', }); /* $2,500.00 */ 

Voici le code Patrick Desjardins (alias Daok) avec quelques commentaires ajoutés et quelques changements mineurs:

 /* decimal_sep: character used as deciaml separtor, it defaults to '.' when omitted thousands_sep: char used as thousands separator, it defaults to ',' when omitted */ Number.prototype.toMoney = function(decimals, decimal_sep, thousands_sep) { var n = this, c = isNaN(decimals) ? 2 : Math.abs(decimals), //if decimal is zero we must take it, it means user does not want to show any decimal d = decimal_sep || '.', //if no decimal separator is passed we use the dot as default decimal separator (we MUST use a decimal separator) /* according to [https://stackoverflow.com/questions/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function] the fastest way to check for not defined parameter is to use typeof value === 'undefined' rather than doing value === undefined. */ t = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep, //if you don't want to use a thousands separator you can pass empty string as thousands_sep value sign = (n < 0) ? '-' : '', //extracting the absolute value of the integer part of the number and converting to string i = parseInt(n = Math.abs(n).toFixed(c)) + '', j = ((j = i.length) > 3) ? j % 3 : 0; return sign + (j ? i.substr(0, j) + t : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : ''); } 

Et voici quelques tests:

 //some tests (do not forget parenthesis when using negative numbers and number with no decimals) alert(123456789.67392.toMoney() + '\n' + 123456789.67392.toMoney(3) + '\n' + 123456789.67392.toMoney(0) + '\n' + (123456).toMoney() + '\n' + (123456).toMoney(0) + '\n' + 89.67392.toMoney() + '\n' + (89).toMoney()); //some tests (do not forget parenthesis when using negative numbers and number with no decimals) alert((-123456789.67392).toMoney() + '\n' + (-123456789.67392).toMoney(-3)); 

Les modifications mineures sont les suivantes:

  1. Déplacé un peu les Math.abs(decimals) à effectuer uniquement quand n'est pas NaN .

  2. decimal_sep ne peut plus être une chaîne vide (une sorte de séparateur décimal est MUST)

  3. Nous utilisons le typeof thousands_sep === 'undefined' comme suggéré dans la meilleure façon de déterminer si un argument n'est pas envoyé à la fonction JavaScript

  4. (+n || 0) n'est pas nécessaire car this s'agit d'un objet Number

Jetez un oeil à l'objet Numéro JavaScript et voyez s'il peut vous aider.

  • toLocaleString() formatera un nombre en utilisant le séparateur de milliers de localisation.
  • toFixed() va arrondir le nombre à un nombre spécifique de décimales.

Pour les utiliser en même temps, la valeur doit être modifiée à nouveau en un nombre puisqu'ils sortent une chaîne.

Exemple:

 Number(someNumber.toFixed(1)).toLocaleString() 

Accounting.js est une petite bibliothèque de JavaScript pour le formatage de numéros, d'argent et de devises.

http://openexchangerates.github.io/accounting.js/

Voici le meilleur formatateur d'argent js que j'ai vu:

 Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator) { var n = this, decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces, decSeparator = decSeparator == undefined ? "." : decSeparator, thouSeparator = thouSeparator == undefined ? "," : thouSeparator, sign = n < 0 ? "-" : "", i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "", j = (j = i.length) > 3 ? j % 3 : 0; return sign + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : ""); }; 

Il a été reformaté et emprunté à partir d'ici: https://stackoverflow.com/a/149099/751484

Vous devrez fournir votre propre désignateur de devises (vous avez utilisé $ ci-dessus).

Appelez-le comme ça (bien que notez que les args sont par défaut pour 2, virgule et période, donc vous n'avez pas besoin de fournir des args si c'est votre préférence):

 var myMoney=3543.75873; var formattedMoney = '$' + myMoney.formatMoney(2,',','.'); // "$3,543.76" 

Je pense que ce que vous voulez est f.nettotal.value = "$" + showValue.toFixed(2);

Si le montant est un nombre, par exemple -123, alors

 amount.toLocaleString('en-US', { style: 'currency', currency: 'USD' }); 

Produira la chaîne "- $ 123.00".

Voici un exemple de travail complet.

Il y a déjà de bonnes réponses ici. Voici une autre tentative, juste pour le plaisir:

 function formatDollar(num) { var p = num.toFixed(2).split("."); return "$" + p[0].split("").reverse().reduce(function(acc, num, i, orig) { return num=="-" ? acc : num + (i && !(i % 3) ? "," : "") + acc; }, "") + "." + p[1]; } 

Et quelques tests:

 formatDollar(45664544.23423) // "$45,664,544.23" formatDollar(45) // "$45.00" formatDollar(123) // "$123.00" formatDollar(7824) // "$7,824.00" formatDollar(1) // "$1.00" 

Édité: maintenant, il traitera aussi les chiffres négatifs

Alors, pourquoi personne n'a-t-il suggéré ce qui suit?

 (2500).toLocaleString("en-GB", {style: "currency", currency: "GBP", minimumFractionDigits: 2}) 

Fonctionne pour la plupart / certains navigateurs:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString#Browser_Compatibility

D'accord, en fonction de ce que vous avez dit, j'utilise ceci:

 var DecimalSeparator = Number("1.2").toLocaleString().substr(1,1); var AmountWithCommas = Amount.toLocaleString(); var arParts = String(AmountWithCommas).split(DecimalSeparator); var intPart = arParts[0]; var decPart = (arParts.length > 1 ? arParts[1] : ''); decPart = (decPart + '00').substr(0,2); return '£ ' + intPart + DecimalSeparator + decPart; 

Je suis ouvert à des suggestions d'amélioration (je préfère ne pas inclure YUI juste pour ce faire :-)) Je sais déjà que je devrais détecter le "." Au lieu de simplement l'utiliser comme séparateur décimal …

J'utilise la bibliothèque Globalize (de Microsoft): https://github.com/jquery/globalize

C'est un excellent projet pour localiser les numéros, les devises et les dates et les avoir formatés automatiquement de la manière appropriée selon les paramètres régionaux de l'utilisateur! … et malgré cela devrait être une extension jQuery, il est actuellement une bibliothèque 100% indépendante. Je vous suggère tous de l'essayer! 🙂

Javascript-number-formatter (anciennement chez Google Code )

  • Court, rapide, flexible mais autonome. Seulement 75 lignes, y compris les informations sur la licence MIT, les lignes vierges et les commentaires.
  • Acceptez le formatage de numéro standard comme #,##0.00 ou avec négation -000.#### .
  • Acceptez n'importe quel format de pays comme # ##0,00 , #,###.## , #'###.## ou tout type de symbole non-numéroté.
  • Acceptez tout nombre de groupes de chiffres. #,##,#0.000 ou #,###0.## sont tous valides.
  • Acceptez tout formatage redondant / imbécile. ##,###,##.# Ou 0#,#00#.###0# sont tous OK.
  • Arrondi des nombres automatiques.
  • Interface simple, fournissez simplement le masque et la valeur comme ceci: format( "0.0000", 3.141592) .
  • Inclure un préfixe et un suffixe avec le masque

(Extrait de son README)

+1 à Jonathan M pour fournir la méthode originale. Comme il s'agit explicitement d'un formateur de devises, je suis allé de l'avant et j'ai ajouté le symbole de la devise (par défaut '' $ ') à la sortie, et ajouté une virgule par défaut comme séparateur de milliers. Si vous ne voulez pas vraiment un symbole de devise (ou un séparateur de milliers), utilisez simplement "" (chaîne vide) comme argument pour cela.

 Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator, currencySymbol) { // check the args and supply defaults: decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces; decSeparator = decSeparator == undefined ? "." : decSeparator; thouSeparator = thouSeparator == undefined ? "," : thouSeparator; currencySymbol = currencySymbol == undefined ? "$" : currencySymbol; var n = this, sign = n < 0 ? "-" : "", i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "", j = (j = i.length) > 3 ? j % 3 : 0; return sign + currencySymbol + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : ""); }; 

Une méthode plus courte (pour insérer l'espace, la virgule ou le point) avec une expression régulière?

  Number.prototype.toCurrencyString=function(){ return this.toFixed(2).replace(/(\d)(?=(\d{3})+\b)/g,'$1 '); } n=12345678.9; alert(n.toCurrencyString()); 

Numeral.js – une bibliothèque js pour un formatage facile de numéros par @adamwdraper

 numeral(23456.789).format('$0,0.00'); // = "$23,456.79" 

Il existe un port javascript de la fonction PHP "number_format".

Je le trouve très utile car il est facile à utiliser et reconnaissable pour les développeurs PHP.

 function number_format (number, decimals, dec_point, thousands_sep) { var n = number, prec = decimals; var toFixedFix = function (n,prec) { var k = Math.pow(10,prec); return (Math.round(n*k)/k).toString(); }; n = !isFinite(+n) ? 0 : +n; prec = !isFinite(+prec) ? 0 : Math.abs(prec); var sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep; var dec = (typeof dec_point === 'undefined') ? '.' : dec_point; var s = (prec > 0) ? toFixedFix(n, prec) : toFixedFix(Math.round(n), prec); //fix for IE parseFloat(0.55).toFixed(0) = 0; var abs = toFixedFix(Math.abs(n), prec); var _, i; if (abs >= 1000) { _ = abs.split(/\D/); i = _[0].length % 3 || 3; _[0] = s.slice(0,i + (n < 0)) + _[0].slice(i).replace(/(\d{3})/g, sep+'$1'); s = _.join(dec); } else { s = s.replace('.', dec); } var decPos = s.indexOf(dec); if (prec >= 1 && decPos !== -1 && (s.length-decPos-1) < prec) { s += new Array(prec-(s.length-decPos-1)).join(0)+'0'; } else if (prec >= 1 && decPos === -1) { s += dec+new Array(prec).join(0)+'0'; } return s; } 

(Bloc de commentaires de l'original , inclus ci-dessous pour les exemples et le crédit s'il est dû)

 // Formats a number with grouped thousands // // version: 906.1806 // discuss at: http://phpjs.org/functions/number_format // + original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com) // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net) // + bugfix by: Michael White (http://getsprink.com) // + bugfix by: Benjamin Lupton // + bugfix by: Allan Jensen (http://www.winternet.no) // + revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com) // + bugfix by: Howard Yeend // + revised by: Luke Smith (http://lucassmith.name) // + bugfix by: Diogo Resende // + bugfix by: Rival // + input by: Kheang Hok Chin (http://www.distantia.ca/) // + improved by: davook // + improved by: Brett Zamir (http://brett-zamir.me) // + input by: Jay Klehr // + improved by: Brett Zamir (http://brett-zamir.me) // + input by: Amir Habibi (http://www.residence-mixte.com/) // + bugfix by: Brett Zamir (http://brett-zamir.me) // * example 1: number_format(1234.56); // * returns 1: '1,235' // * example 2: number_format(1234.56, 2, ',', ' '); // * returns 2: '1 234,56' // * example 3: number_format(1234.5678, 2, '.', ''); // * returns 3: '1234.57' // * example 4: number_format(67, 2, ',', '.'); // * returns 4: '67,00' // * example 5: number_format(1000); // * returns 5: '1,000' // * example 6: number_format(67.311, 2); // * returns 6: '67.31' // * example 7: number_format(1000.55, 1); // * returns 7: '1,000.6' // * example 8: number_format(67000, 5, ',', '.'); // * returns 8: '67.000,00000' // * example 9: number_format(0.9, 0); // * returns 9: '1' // * example 10: number_format('1.20', 2); // * returns 10: '1.20' // * example 11: number_format('1.20', 4); // * returns 11: '1.2000' // * example 12: number_format('1.2000', 3); // * returns 12: '1.200' 

La réponse de Patrick Desjardins semble bonne, mais je préfère mon javascript simple. Voici une fonction que je viens d'écrire pour prendre un numéro et le renvoyer en format de devise (moins le signe dollar)

 // Format numbers to two decimals with commas function formatDollar(num) { var p = num.toFixed(2).split("."); var chars = p[0].split("").reverse(); var newstr = ''; var count = 0; for (x in chars) { count++; if(count%3 == 1 && count != 1) { newstr = chars[x] + ',' + newstr; } else { newstr = chars[x] + newstr; } } return newstr + "." + p[1]; } 

Il existe une function Fixed in javascript

 var num = new Number(349); document.write("$" + num.toFixed(2)); 

I suggest the NumberFormat class from Google Visualization API .

You can do something like this:

 var formatter = new google.visualization.NumberFormat({ prefix: '$', pattern: '#,###,###.##' }); formatter.formatValue(1000000); // $ 1,000,000 

J'espère que cela vous aidera.

 function CurrencyFormatted(amount) { var i = parseFloat(amount); if(isNaN(i)) { i = 0.00; } var minus = ''; if(i < 0) { minus = '-'; } i = Math.abs(i); i = parseInt((i + .005) * 100); i = i / 100; s = new String(i); if(s.indexOf('.') < 0) { s += '.00'; } if(s.indexOf('.') == (s.length - 2)) { s += '0'; } s = minus + s; return s; } 

From WillMaster .

The main part is inserting the thousand-separators, that could be done like this:

 <script type="text/javascript"> function ins1000Sep(val){ val = val.split("."); val[0] = val[0].split("").reverse().join(""); val[0] = val[0].replace(/(\d{3})/g,"$1,"); val[0] = val[0].split("").reverse().join(""); val[0] = val[0].indexOf(",")==0?val[0].substring(1):val[0]; return val.join("."); } function rem1000Sep(val){ return val.replace(/,/g,""); } function formatNum(val){ val = Math.round(val*100)/100; val = (""+val).indexOf(".")>-1 ? val + "00" : val + ".00"; var dec = val.indexOf("."); return dec == val.length-3 || dec == 0 ? val : val.substring(0,dec+3); } </script> <button onclick="alert(ins1000Sep(formatNum(12313231)));"> 

This might be a little late, but here's a method I just worked up for a coworker to add a locale-aware .toCurrencyString() function to all numbers. The internalization is for number grouping only, NOT the currency sign – if you're outputting dollars, use "$" as supplied, because $123 4567 in Japan or China is the same number of USD as $1,234,567 is here in the US. If you're outputting euro/etc., then change the currency sign from "$".

Declare this anywhere in your HEAD or wherever necessary, just before you need to use it:

  Number.prototype.toCurrencyString = function(prefix, suffix) { if (typeof prefix === 'undefined') { prefix = '$'; } if (typeof suffix === 'undefined') { suffix = ''; } var _localeBug = new RegExp((1).toLocaleString().replace(/^1/, '').replace(/\./, '\\.') + "$"); return prefix + (~~this).toLocaleString().replace(_localeBug, '') + (this % 1).toFixed(2).toLocaleString().replace(/^[+-]?0+/,'') + suffix; } 

Then you're done! Use (number).toCurrencyString() anywhere you need to output the number as currency.

 var MyNumber = 123456789.125; alert(MyNumber.toCurrencyString()); // alerts "$123,456,789.13" MyNumber = -123.567; alert(MyNumber.toCurrencyString()); // alerts "$-123.57" 

As usually, there are multiple ways of doing the same thing but I would avoid using Number.prototype.toLocaleString since it can return different values based on the user settings.

I also don't recommend extending the Number.prototype – extending native objects prototypes is a bad practice since it can cause conflicts with other people code (eg libraries/frameworks/plugins) and may not be compatible with future JavaScript implementations/versions.

I believe that Regular Expressions are the best approach for the problem, here is my implementation:

 /** * Converts number into currency format * @param {number} number Number that should be converted. * @param {string} [decimalSeparator] Decimal separator, defaults to '.'. * @param {string} [thousandsSeparator] Thousands separator, defaults to ','. * @param {int} [nDecimalDigits] Number of decimal digits, defaults to `2`. * @return {string} Formatted string (eg numberToCurrency(12345.67) returns '12,345.67') */ function numberToCurrency(number, decimalSeparator, thousandsSeparator, nDecimalDigits){ //default values decimalSeparator = decimalSeparator || '.'; thousandsSeparator = thousandsSeparator || ','; nDecimalDigits = nDecimalDigits == null? 2 : nDecimalDigits; var fixed = number.toFixed(nDecimalDigits), //limit/add decimal digits parts = new RegExp('^(-?\\d{1,3})((?:\\d{3})+)(\\.(\\d{'+ nDecimalDigits +'}))?$').exec( fixed ); //separate begin [$1], middle [$2] and decimal digits [$4] if(parts){ //number >= 1000 || number <= -1000 return parts[1] + parts[2].replace(/\d{3}/g, thousandsSeparator + '$&') + (parts[4] ? decimalSeparator + parts[4] : ''); }else{ return fixed.replace('.', decimalSeparator); } } 

edited on 2010/08/30: added option to set number of decimal digits. edited on 2011/08/23: added option to set number of decimal digits to zero.

Here are some solutions, all pass the test suite, test suite and benchmark included, if you want copy and paste to test, try This Gist .

Method 0 (RegExp)

Base on https://stackoverflow.com/a/14428340/1877620 , but fix if there is no decimal point.

 if (typeof Number.prototype.format === 'undefined') { Number.prototype.format = function (precision) { if (!isFinite(this)) { return this.toString(); } var a = this.toFixed(precision).split('.'); a[0] = a[0].replace(/\d(?=(\d{3})+$)/g, '$&,'); return a.join('.'); } } 

Méthode 1

 if (typeof Number.prototype.format === 'undefined') { Number.prototype.format = function (precision) { if (!isFinite(this)) { return this.toString(); } var a = this.toFixed(precision).split('.'), // skip the '-' sign head = Number(this < 0); // skip the digits that's before the first thousands separator head += (a[0].length - head) % 3 || 3; a[0] = a[0].slice(0, head) + a[0].slice(head).replace(/\d{3}/g, ',$&'); return a.join('.'); }; } 

Method 2 (Split to Array)

 if (typeof Number.prototype.format === 'undefined') { Number.prototype.format = function (precision) { if (!isFinite(this)) { return this.toString(); } var a = this.toFixed(precision).split('.'); a[0] = a[0] .split('').reverse().join('') .replace(/\d{3}(?=\d)/g, '$&,') .split('').reverse().join(''); return a.join('.'); }; } 

Method 3 (Loop)

 if (typeof Number.prototype.format === 'undefined') { Number.prototype.format = function (precision) { if (!isFinite(this)) { return this.toString(); } var a = this.toFixed(precision).split(''); a.push('.'); var i = a.indexOf('.') - 3; while (i > 0 && a[i-1] !== '-') { a.splice(i, 0, ','); i -= 3; } a.pop(); return a.join(''); }; } 

Usage Example

 console.log('======== Demo ========') console.log( (1234567).format(0), (1234.56).format(2), (-1234.56).format(0) ); var n = 0; for (var i=1; i<20; i++) { n = (n * 10) + (i % 10)/100; console.log(n.format(2), (-n).format(2)); } 

Séparateur

If we want custom thousands separator or decimal separator, use replace() :

 123456.78.format(2).replace(',', ' ').replace('.', ' '); 

Test suite

 function assertEqual(a, b) { if (a !== b) { throw a + ' !== ' + b; } } function test(format_function) { console.log(format_function); assertEqual('NaN', format_function.call(NaN, 0)) assertEqual('Infinity', format_function.call(Infinity, 0)) assertEqual('-Infinity', format_function.call(-Infinity, 0)) assertEqual('0', format_function.call(0, 0)) assertEqual('0.00', format_function.call(0, 2)) assertEqual('1', format_function.call(1, 0)) assertEqual('-1', format_function.call(-1, 0)) // decimal padding assertEqual('1.00', format_function.call(1, 2)) assertEqual('-1.00', format_function.call(-1, 2)) // decimal rounding assertEqual('0.12', format_function.call(0.123456, 2)) assertEqual('0.1235', format_function.call(0.123456, 4)) assertEqual('-0.12', format_function.call(-0.123456, 2)) assertEqual('-0.1235', format_function.call(-0.123456, 4)) // thousands separator assertEqual('1,234', format_function.call(1234.123456, 0)) assertEqual('12,345', format_function.call(12345.123456, 0)) assertEqual('123,456', format_function.call(123456.123456, 0)) assertEqual('1,234,567', format_function.call(1234567.123456, 0)) assertEqual('12,345,678', format_function.call(12345678.123456, 0)) assertEqual('123,456,789', format_function.call(123456789.123456, 0)) assertEqual('-1,234', format_function.call(-1234.123456, 0)) assertEqual('-12,345', format_function.call(-12345.123456, 0)) assertEqual('-123,456', format_function.call(-123456.123456, 0)) assertEqual('-1,234,567', format_function.call(-1234567.123456, 0)) assertEqual('-12,345,678', format_function.call(-12345678.123456, 0)) assertEqual('-123,456,789', format_function.call(-123456789.123456, 0)) // thousands separator and decimal assertEqual('1,234.12', format_function.call(1234.123456, 2)) assertEqual('12,345.12', format_function.call(12345.123456, 2)) assertEqual('123,456.12', format_function.call(123456.123456, 2)) assertEqual('1,234,567.12', format_function.call(1234567.123456, 2)) assertEqual('12,345,678.12', format_function.call(12345678.123456, 2)) assertEqual('123,456,789.12', format_function.call(123456789.123456, 2)) assertEqual('-1,234.12', format_function.call(-1234.123456, 2)) assertEqual('-12,345.12', format_function.call(-12345.123456, 2)) assertEqual('-123,456.12', format_function.call(-123456.123456, 2)) assertEqual('-1,234,567.12', format_function.call(-1234567.123456, 2)) assertEqual('-12,345,678.12', format_function.call(-12345678.123456, 2)) assertEqual('-123,456,789.12', format_function.call(-123456789.123456, 2)) } console.log('======== Testing ========'); test(Number.prototype.format); test(Number.prototype.format1); test(Number.prototype.format2); test(Number.prototype.format3); 

Benchmark

 function benchmark(f) { var start = new Date().getTime(); f(); return new Date().getTime() - start; } function benchmark_format(f) { console.log(f); time = benchmark(function () { for (var i = 0; i < 100000; i++) { f.call(123456789, 0); f.call(123456789, 2); } }); console.log(time.format(0) + 'ms'); } // if not using async, browser will stop responding while running. // this will create a new thread to benchmark async = []; function next() { setTimeout(function () { f = async.shift(); f && f(); next(); }, 10); } console.log('======== Benchmark ========'); async.push(function () { benchmark_format(Number.prototype.format); }); next(); 

A simple option for proper comma placement by reversing the string first and basic regexp.

 String.prototype.reverse = function() { return this.split('').reverse().join(''); }; Number.prototype.toCurrency = function( round_decimal /*boolean*/ ) { // format decimal or round to nearest integer var n = this.toFixed( round_decimal ? 0 : 2 ); // convert to a string, add commas every 3 digits from left to right // by reversing string return (n + '').reverse().replace( /(\d{3})(?=\d)/g, '$1,' ).reverse(); }; 

Patrick Desjardins (ex Daok)'s example worked well for me. I ported over to coffeescript if anyone is interested.

 Number.prototype.toMoney = (decimals = 2, decimal_separator = ".", thousands_separator = ",") -> n = this c = if isNaN(decimals) then 2 else Math.abs decimals sign = if n < 0 then "-" else "" i = parseInt(n = Math.abs(n).toFixed(c)) + '' j = if (j = i.length) > 3 then j % 3 else 0 x = if j then i.substr(0, j) + thousands_separator else '' y = i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands_separator) z = if c then decimal_separator + Math.abs(n - i).toFixed(c).slice(2) else '' sign + x + y + z 

I found this from: accounting.js . Its very easy and perfectly fits my need.

 // Default usage: accounting.formatMoney(12345678); // $12,345,678.00 // European formatting (custom symbol and separators), can also use options object as second parameter: accounting.formatMoney(4999.99, "€", 2, ".", ","); // €4.999,99 // Negative values can be formatted nicely: accounting.formatMoney(-500000, "£ ", 0); // £ -500,000 // Simple `format` string allows control of symbol position (%v = value, %s = symbol): accounting.formatMoney(5318008, { symbol: "GBP", format: "%v %s" }); // 5,318,008.00 GBP // Euro currency symbol to the right accounting.formatMoney(5318008, {symbol: "€", precision: 2, thousand: ".", decimal : ",", format: "%v%s"}); // 1.008,00€ 

The YUI codebase uses the following formmating:

 format: function(nData, oConfig) { oConfig = oConfig || {}; if(!YAHOO.lang.isNumber(nData)) { nData *= 1; } if(YAHOO.lang.isNumber(nData)) { var sOutput = nData + ""; var sDecimalSeparator = (oConfig.decimalSeparator) ? oConfig.decimalSeparator : "."; var nDotIndex; // Manage decimals if(YAHOO.lang.isNumber(oConfig.decimalPlaces)) { // Round to the correct decimal place var nDecimalPlaces = oConfig.decimalPlaces; var nDecimal = Math.pow(10, nDecimalPlaces); sOutput = Math.round(nData*nDecimal)/nDecimal + ""; nDotIndex = sOutput.lastIndexOf("."); if(nDecimalPlaces > 0) { // Add the decimal separator if(nDotIndex < 0) { sOutput += sDecimalSeparator; nDotIndex = sOutput.length-1; } // Replace the "." else if(sDecimalSeparator !== "."){ sOutput = sOutput.replace(".",sDecimalSeparator); } // Add missing zeros while((sOutput.length - 1 - nDotIndex) < nDecimalPlaces) { sOutput += "0"; } } } // Add the thousands separator if(oConfig.thousandsSeparator) { var sThousandsSeparator = oConfig.thousandsSeparator; nDotIndex = sOutput.lastIndexOf(sDecimalSeparator); nDotIndex = (nDotIndex > -1) ? nDotIndex : sOutput.length; var sNewOutput = sOutput.substring(nDotIndex); var nCount = -1; for (var i=nDotIndex; i>0; i--) { nCount++; if ((nCount%3 === 0) && (i !== nDotIndex)) { sNewOutput = sThousandsSeparator + sNewOutput; } sNewOutput = sOutput.charAt(i-1) + sNewOutput; } sOutput = sNewOutput; } // Prepend prefix sOutput = (oConfig.prefix) ? oConfig.prefix + sOutput : sOutput; // Append suffix sOutput = (oConfig.suffix) ? sOutput + oConfig.suffix : sOutput; return sOutput; } // Still not a Number, just return unaltered else { return nData; } } 

it would need editing as the YUI library is configurable, like replacing oConfig.decimalSeparator with "."

JavaScript rend le site Web intelligent, beauté et facile à utiliser.