小开

主要部分是插入千分隔符，可以这样做：

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

小开

Number.prototype.to修复

此解决方案与每个主要浏览器兼容：

  const profits = 2489.8237;
profits.toFixed(3) // Returns 2489.824 (rounds up)profits.toFixed(2) // Returns 2489.82profits.toFixed(7) // Returns 2489.8237000 (pads the decimals)

您只需要添加货币符号（例如"$" + profits.toFixed(2)），您就可以获得美元金额。

自定义函数

如果您需要在每个数字之间使用,，您可以使用此功能：

function formatMoney(number, decPlaces, decSep, thouSep) {decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,decSep = typeof decSep === "undefined" ? "." : decSep;thouSep = typeof thouSep === "undefined" ? "," : thouSep;var sign = number < 0 ? "-" : "";var i = String(parseInt(number = Math.abs(Number(number) || 0).toFixed(decPlaces)));var j = (j = i.length) > 3 ? j % 3 : 0;
return sign +(j ? i.substr(0, j) + thouSep : "") +i.substr(j).replace(/(\decSep{3})(?=\decSep)/g, "$1" + thouSep) +(decPlaces ? decSep + Math.abs(number - i).toFixed(decPlaces).slice(2) : "");}
document.getElementById("b").addEventListener("click", event => {document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);});

<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label><br /><button id="b">Get Output</button><p id="x">(press button to get output)</p>

像这样使用它：

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

如果您总是要使用“.”和“，”，您可以将它们从方法调用中删除，该方法将为您默认它们。

(123456789.12345).formatMoney(2);

如果您的区域性翻转了两个符号（即Europeans）并且您想使用默认值，只需在formatMoney方法中粘贴以下两行：

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

自定义功能（ES6）

如果您可以使用现代ECMAScript语法（即通过Babel），则可以使用以下更简单的函数：

function formatMoney(amount, decimalCount = 2, decimal = ".", thousands = ",") {try {decimalCount = Math.abs(decimalCount);decimalCount = isNaN(decimalCount) ? 2 : decimalCount;
const negativeSign = amount < 0 ? "-" : "";
let i = parseInt(amount = Math.abs(Number(amount) || 0).toFixed(decimalCount)).toString();let j = (i.length > 3) ? i.length % 3 : 0;
returnnegativeSign +(j ? i.substr(0, j) + thousands : '') +i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands) +(decimalCount ? decimal + Math.abs(amount - i).toFixed(decimalCount).slice(2) : "");} catch (e) {console.log(e)}};
document.getElementById("b").addEventListener("click", event => {document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);});

<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label><br /><button id="b">Get Output</button><p id="x">(press button to get output)</p>

小开

看看JavaScript数量对象，看看它是否可以帮助你。

toLocaleString()将使用位置特定的千分隔符格式化数字。
toFixed()将数字四舍五入到特定的小数位数。

要同时使用它们，值必须将其类型更改回数字，因为它们都输出一个字符串。

示例：

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

编辑

可以直接使用toLocaleString，不需要重新转换为数字：

someNumber.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2});

多个数字

如果您需要频繁地以类似的方式格式化数字，您可以创建一个特定的对象以供重用。就像德语（瑞士）一样：

const money = new Intl.NumberFormat('de-CH',{ style:'currency', currency: 'CHF' });const percent = new Intl.NumberFormat('de-CH',{ style:'percent', maximumFractionDigits: 1, signDisplay: "always"});

它可以用作：

money.format(1234.50); // output CHF 1'234.50percent.format(0.083);  // output +8.3%

很漂亮。

小开

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

从WillMaster。

小开

YUI代码库使用以下格式：

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 decimalsif(YAHOO.lang.isNumber(oConfig.decimalPlaces)) {// Round to the correct decimal placevar nDecimalPlaces = oConfig.decimalPlaces;var nDecimal = Math.pow(10, nDecimalPlaces);sOutput = Math.round(nData*nDecimal)/nDecimal + "";nDotIndex = sOutput.lastIndexOf(".");
if(nDecimalPlaces > 0) {// Add the decimal separatorif(nDotIndex < 0) {sOutput += sDecimalSeparator;nDotIndex = sOutput.length-1;}// Replace the "."else if(sDecimalSeparator !== "."){sOutput = sOutput.replace(".",sDecimalSeparator);}// Add missing zeroswhile((sOutput.length - 1 - nDotIndex) < nDecimalPlaces) {sOutput += "0";}}}
// Add the thousands separatorif(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 prefixsOutput = (oConfig.prefix) ? oConfig.prefix + sOutput : sOutput;
// Append suffixsOutput = (oConfig.suffix) ? sOutput + oConfig.suffix : sOutput;
return sOutput;}// Still not a number. Just return it unalteredelse {return nData;}}

它需要编辑，因为YUI库是可配置的，例如将oConfig.decimal分隔符替换为“.”。

小开

最佳答案

好吧，根据你所说的，我用这个：

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;

我对改进建议持开放态度（我宁愿不包括YUI只是为了做到这一点：-））

我已经知道我应该检测“.”而不仅仅是将其用作小数分隔符…

小开

一个简单的方法，刚好满足原始要求：

function formatMoney(n) {return "$ " + (Math.round(n * 100) / 100).toLocaleString();}

@陈志立：你说得对。以上是一个仓促、不完整的实现。以下是更正后的实现：

function formatMoney(n) {return "$ " + n.toLocaleString().split(".")[0] + "."+ n.toFixed(2).split(".")[1];}

小开

有一个PHP函数“number_format”的JavaScript端口。

我发现它非常有用，因为它易于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 Internet Explorer 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;}

（来自的原始的评论块，包括下面的示例和到期的信用）

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

小开

下面是Patrick Desjardins（别名Daok）代码，添加了一些注释和一些小的更改：

/*decimal_sep: character used as decimal separator, it defaults to '.' when omittedthousands_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 the user does not want to show any decimald = 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 stringi = 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) : '');}

这里有一些测试：

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

小改动是：

将Math.abs(decimals)移动了一点，只有当不是NaN时才能完成。
decimal_sep不能再是空字符串了（某种小数分隔符是必须）
我们按照如何最好地确定参数是否未发送到JavaScript函数中的建议使用typeof thousands_sep === 'undefined'
不需要(+n || 0)，因为this是Number对象

JSFiddle

小开

function getMoney(A){var a = new Number(A);var b = a.toFixed(2); // Get 12345678.90a = parseInt(a); // Get 12345678b = (b-a).toPrecision(2); // Get 0.90b = parseFloat(b).toFixed(2); // In case we get 0.0, we pad it out to 0.00a = a.toLocaleString(); // Put in commas - Internet Explorer also puts in .00, so we'll get 12,345,678.00// If Internet Explorer (our number ends in .00)if(a < 1 && a.lastIndexOf('.00') == (a.length - 3)){a = a.substr(0, a.length-3); // Delete the .00}return a + b.substr(1); // Remove the 0 from b, then return a + b = 12,345,678.90}alert(getMoney(12345678.9));

这适用于Firefox和Internet Explorer。

小开

通常，有多种方法可以做同样的事情，但我会避免使用Number.prototype.toLocaleString，因为它可以根据用户设置返回不同的值。

我也不建议扩展Number.prototype——扩展原生对象原型是一种不好的做法，因为它可能会导致与其他人代码（例如库/框架/插件）的冲突，并且可能与未来的JavaScript实现/版本不兼容。

我相信正则表达式是解决问题的最佳方法，下面是我的实现：

/*** 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 (e.g. numberToCurrency(12345.67) returns '12,345.67')*/function numberToCurrency(number, decimalSeparator, thousandsSeparator, nDecimalDigits){//default valuesdecimalSeparator = decimalSeparator || '.';thousandsSeparator = thousandsSeparator || ',';nDecimalDigits = nDecimalDigits == null? 2 : nDecimalDigits;
var fixed = number.toFixed(nDecimalDigits), //limit/add decimal digitsparts = 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 <= -1000return parts[1] + parts[2].replace(/\d{3}/g, thousandsSeparator + '$&') + (parts[4] ? decimalSeparator + parts[4] : '');}else{return fixed.replace('.', decimalSeparator);}}

小开

这是另一个尝试，只是为了好玩：

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

一些测试：

formatDollar(45664544.23423) // "$45,664,544.23"formatDollar(45) // "$45.00"formatDollar(123) // "$123.00"formatDollar(7824) // "$7,824.00"formatDollar(1) // "$1.00"formatDollar(-1345) // "$-1,345.00formatDollar(-3) // "$-3.00"

小开

Patrick Desjardins（前Daok）的例子对我很有效。如果有人感兴趣，我将它移植到CoffeeScript。

Number.prototype.toMoney = (decimals = 2, decimal_separator = ".", thousands_separator = ",") ->n = thisc = if isNaN(decimals) then 2 else Math.abs decimalssign = if n < 0 then "-" else ""i = parseInt(n = Math.abs(n).toFixed(c)) + ''j = if (j = i.length) > 3 then j % 3 else 0x = 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

小开

这可能会奏效：

function format_currency(v, number_of_decimals, decimal_separator, currency_sign){return (isNaN(v)? v : currency_sign + parseInt(v||0).toLocaleString() + decimal_separator + (v*1).toFixed(number_of_decimals).slice(-number_of_decimals));}

没有循环，没有正则表达式，没有数组，没有奇异的条件。

小开

javascript-数字-格式化程序（原在google code）

短，快速，灵活但独立。
接受标准数字格式，如#,##0.00或否定-000.####。
接受任何国家格式，如# ##0,00、#,###.##、#'###.##或任何类型的非编号符号。
接受任意数字分组。#,##,#0.000或#,###0.##都有效。
接受任何冗余/万无一失的格式。##,###,##.#或0#,#00#.###0#都可以。
自动数字舍入。
简单的界面，只需提供掩码和值，如下所示：format( "0.0000", 3.141592)。
在掩码中包含前缀和后缀

（摘自README）

小开

我使用库全球化（来自Microsoft）：

这是一个很好的项目，可以本地化数字，货币和日期，并根据用户语言环境自动格式化它们！…尽管它应该是一个jQuery扩展，但它目前是一个100%独立的库。我建议大家尝试一下！：）

小开

accounting.js是一个用于数字、货币和货币格式的小型JavaScript库。

小开

使用regexp的更快方法：

Number.prototype.toMonetaryString = function() {var n = this.toFixed(2), m;//var = this.toFixed(2).replace(/\./, ','); For comma separator// with a space for thousands separatorwhile ((m = n.replace(/(\d)(\d\d\d)\b/g, '$1 $2')) != n)n = m;return m;}
String.prototype.fromMonetaryToNumber = function(s) {return this.replace(/[^\d-]+/g, '')/100;}

小开

通过反转字符串first和基本regexp来正确放置逗号的简单选项。

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

小开

带有正则表达式的较短方法（用于插入空格、逗号或点）：

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

小开

JavaScript中没有等效的“formatNumber”。您可以自己编写它或找到一个已经这样做的库。

小开

我认为你想要：

f.nettotal.value = "$" + showValue.toFixed(2);

小开

这是我见过的最好的JavaScript货币格式化程序：

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

它被重新格式化并从这里借用：如何将数字格式化为货币字符串

您必须提供自己的货币代号（您在上面使用了$）。

这样称呼它（尽管注意参数默认为2、逗号和句点，所以如果这是你的偏好，你不需要提供任何参数）：

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

小开

在JavaScript中有一个内置函数到固定：

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

小开

Patrick Desjardins'的答案看起来不错，但我更喜欢简单的JavaScript代码。这是我刚刚编写的一个函数，用于接收一个数字并以货币格式返回它（减去美元符号）：

// Format numbers to two decimals with commasfunction 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];}

小开

String.prototype.toPrice = function () {var v;if (/^\d+(,\d+)$/.test(this))v = this.replace(/,/, '.');else if (/^\d+((,\d{3})*(\.\d+)?)?$/.test(this))v = this.replace(/,/g, "");else if (/^\d+((.\d{3})*(,\d+)?)?$/.test(this))v = this.replace(/\./g, "").replace(/,/, ".");var x = parseFloat(v).toFixed(2).toString().split("."),x1 = x[0],x2 = ((x.length == 2) ? "." + x[1] : ".00"),exp = /^([0-9]+)(\d{3})/;while (exp.test(x1))x1 = x1.replace(exp, "$1" + "," + "$2");return x1 + x2;}
alert("123123".toPrice()); //123,123.00alert("123123,316".toPrice()); //123,123.32alert("12,312,313.33213".toPrice()); //12,312,313.33alert("123.312.321,32132".toPrice()); //123,312,321.32

小开

+1到Jonathan M提供原始方法。由于这显然是一个货币格式化程序，我继续将货币符号（默认为'$'）添加到输出中，并添加了一个默认逗号作为千分隔符。如果您实际上不想要货币符号（或千分隔符），只需使用“”（空字符串）作为它的参数。

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

小开

派屈克的回答的CoffeeScript：

Number::formatMoney = (decimalPlaces, decimalChar, thousandsChar) ->n = thisc = decimalPlacesd = decimalChart = thousandsCharc = (if isNaN(c = Math.abs(c)) then 2 else c)d = (if d is undefined then "." else d)t = (if t is undefined then "," else t)s = (if n < 0 then "-" else "")i = parseInt(n = Math.abs(+n or 0).toFixed(c)) + ""j = (if (j = i.length) > 3 then j % 3 else 0)s + (if j then i.substr(0, j) + t else "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (if c then d + Math.abs(n - i).toFixed(c).slice(2) else "")

小开

Numeral.js-一个JavaScript库，用于@adamwdraper轻松格式化数字

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

小开

我建议使用谷歌可视化API中的NumberFormat类。

你可以这样做：

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

小开

这是我的…

function thousandCommas(num) {num = num.toString().split('.');var ints = num[0].split('').reverse();for (var out=[],len=ints.length,i=0; i < len; i++) {if (i > 0 && (i % 3) === 0) out.push(',');out.push(ints[i]);}out = out.reverse() && out.join('');if (num.length === 2) out += '.' + num[1];return out;}

小开

http://code.google.com/p/javascript-number-formatter/：

简短、快速、灵活但独立。只有75行，包括MIT许可证信息、空行和注释。
接受标准数字格式，如#、##0.00或否定-000. ####.
接受任何国家格式，如###0,00, #,###. ##, #'###.## 或任何类型的非编号符号。
接受任何数字分组. #,##,#0.000或#、###0.##均有效。
接受任何冗余/防傻瓜格式. ##,###,##.# 或0#、#00#。###0#都可以。
自动数字舍入。
简单的界面，只需要像这样提供掩码和值：格式（"0.0000"，3.141592）

更新这是我自己开发的用于最常见任务的pp实用程序：

var NumUtil = {};
/**Petty print 'num' wth exactly 'signif' digits.pp(123.45, 2) == "120"pp(0.012343, 3) == "0.0123"pp(1.2, 3) == "1.20"*/NumUtil.pp = function(num, signif) {if (typeof(num) !== "number")throw 'NumUtil.pp: num is not a number!';if (isNaN(num))throw 'NumUtil.pp: num is NaN!';if (num < 1e-15 || num > 1e15)return num;var r = Math.log(num)/Math.LN10;var dot = Math.floor(r) - (signif-1);r = r - Math.floor(r) + (signif-1);r = Math.round(Math.exp(r * Math.LN10)).toString();if (dot >= 0) {for (; dot > 0; dot -= 1)r += "0";return r;} else if (-dot >= r.length) {var p = "0.";for (; -dot > r.length; dot += 1) {p += "0";}return p+r;} else {return r.substring(0, r.length + dot) + "." + r.substring(r.length + dot);}}
/** Append leading zeros up to 2 digits. */NumUtil.align2 = function(v) {if (v < 10)return "0"+v;return ""+v;}/** Append leading zeros up to 3 digits. */NumUtil.align3 = function(v) {if (v < 10)return "00"+v;else if (v < 100)return "0"+v;return ""+v;}
NumUtil.integer = {};
/** Round to integer and group by 3 digits. */NumUtil.integer.pp = function(num) {if (typeof(num) !== "number") {console.log("%s", new Error().stack);throw 'NumUtil.integer.pp: num is not a number!';}if (isNaN(num))throw 'NumUtil.integer.pp: num is NaN!';if (num > 1e15)return num;if (num < 0)throw 'Negative num!';num = Math.round(num);var group = num % 1000;var integ = Math.floor(num / 1000);if (integ === 0) {return group;}num = NumUtil.align3(group);while (true) {group = integ % 1000;integ = Math.floor(integ / 1000);if (integ === 0)return group + " " + num;num = NumUtil.align3(group) + " " + num;}return num;}
NumUtil.currency = {};
/** Round to coins and group by 3 digits. */NumUtil.currency.pp = function(amount) {if (typeof(amount) !== "number")throw 'NumUtil.currency.pp: amount is not a number!';if (isNaN(amount))throw 'NumUtil.currency.pp: amount is NaN!';if (amount > 1e15)return amount;if (amount < 0)throw 'Negative amount!';if (amount < 1e-2)return 0;var v = Math.round(amount*100);var integ = Math.floor(v / 100);var frac = NumUtil.align2(v % 100);var group = integ % 1000;integ = Math.floor(integ / 1000);if (integ === 0) {return group + "." + frac;}amount = NumUtil.align3(group);while (true) {group = integ % 1000;integ = Math.floor(integ / 1000);if (integ === 0)return group + " " + amount + "." + frac;amount = NumUtil.align3(group) + " " + amount;}return amount;}

小开

简短快速的解决方案（适用于任何地方！）

(12345.67).toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');  // 12,345.67

这个解决方案背后的想法是用第一个匹配和逗号替换匹配的部分，即'$&,'。匹配是使用前瞻方法完成的。您可以将表达式阅读为"匹配一个数字，如果它后面跟着三个数字集（一个或多个）和一个点的序列"。

测试：

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"

演示：http://jsfiddle.net/hAfMM/9571/

扩展短解

您还可以扩展#0对象的原型以添加对任意数量的小数[0 .. n]和数字组[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"

演示/测试：http://jsfiddle.net/hAfMM/435/

超扩展短解

在这个超级加长版中，您可以设置不同的分隔符类型：

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

演示/测试：http://jsfiddle.net/hAfMM/612/

小开

这是XMLilley提供的代码中的moools 1.2实现…

Number.implement('format', function(decPlaces, thouSeparator, decSeparator){decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;decSeparator = decSeparator === undefined ? '.' : decSeparator;thouSeparator = thouSeparator === undefined ? ',' : thouSeparator;
var num = this,sign = num < 0 ? '-' : '',i = parseInt(num = Math.abs(+num || 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(num - i).toFixed(decPlaces).slice(2) : '');});

小开

这可能有点晚了，但这是我刚刚为同事想出的一个方法，为所有数字添加一个语言环境感知的.toCurrencyString()函数。内部化仅用于数字分组，没有货币符号-如果你输出美元，请使用提供的"$"，因为日本或中国的$123 4567与美国的$1,234,567是相同的美元数量。如果你输出欧元等，然后从"$"更改货币符号。

在您的超文本标记语言部分的任何地方或任何必要的地方声明这一点，就在您需要使用它之前：

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

然后你就完成了！在任何需要输出数字作为货币的地方使用(number).toCurrencyString()。

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

小开

我在很大程度上基于来自VisioN的答案：

function format (val) {val = (+val).toLocaleString();val = (+val).toFixed(2);val += "";return val.replace(/(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1" + format.thousands);}
(function (isUS) {format.decimal =   isUS ? "." : ",";format.thousands = isUS ? "," : ".";}(("" + (+(0.00).toLocaleString()).toFixed(2)).indexOf(".") > 0));

我测试了输入：

[   "", "1", "12", "123", "1234", "12345", "123456", "1234567", "12345678", "123456789", "1234567890", ".12", "1.12", "12.12", "123.12", "1234.12", "12345.12", "123456.12", "1234567.12", "12345678.12", "123456789.12", "1234567890.12", "1234567890.123", "1234567890.125"].forEach(function (item) {console.log(format(item));});

得到了这些结果：

0.001.0012.00123.001,234.0012,345.00123,456.001,234,567.0012,345,678.00123,456,789.001,234,567,890.000.121.1212.12123.121,234.1212,345.12123,456.121,234,567.1212,345,678.12123,456,789.121,234,567,890.121,234,567,890.121,234,567,890.13

只是为了好玩。

小开

int. NumberFormat

JavaScript有一个数字格式化程序（国际化API的一部分）。

// Create our number formatter.const formatter = new Intl.NumberFormat('en-US', {style: 'currency',currency: 'USD',
// These options are needed to round to whole numbers if that's what you want.//minimumFractionDigits: 0, // (this suffices for whole numbers, but will print 2500.10 as $2,500.1)//maximumFractionDigits: 0, // (causes 2500.99 to be printed as $2,501)});
console.log(formatter.format(2500)); /* $2,500.00 */

使用undefined代替第一个参数（示例中的'en-US'）来使用系统区域设置（代码在浏览器中运行时的用户区域设置）。进一步解释语言环境代码。

这是一个货币代码列表。

NumberFormat vsNumber.prototype.toLocaleString

最后要注意的是，将其与旧的.toLocaleString进行比较。它们都提供了基本相同的功能。然而，toLocaleString在其较早的化身（pre-Intl）实际上不支持locale中：它使用系统语言环境。因此，在调试旧浏览器时，请确保您使用的是正确的版本（MDN建议检查#1的存在）。如果您不关心旧浏览器或仅使用垫片，则根本无需担心这一点。

此外，对于单一项目，两者的性能是相同的，但是如果你有很多数字要格式化，使用Intl.NumberFormat要快约70倍。因此，通常最好使用Intl.NumberFormat并且每次页面加载只实例化一次。无论如何，这是toLocaleString的等效用法：

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

关于浏览器支持和Node.js的一些说明

如今，浏览器支持不再是一个问题，全球支持率为98%，美国为99%，欧盟为99%以上
有一个垫片来支持它在化石浏览器上（如Internet Explorer 8），如果你真的需要
Node.jsv13之前只支持en-US开箱即用。一种解决方案是安装全重症监护室，有关详细信息，请参阅这里
查看可以使用以获取更多信息

小开

这个答案符合以下标准：

不依赖于外部依赖。
支持本地化。
有测试/证明。
使用简单和最佳编码实践（没有复杂的正则表达式并使用标准编码模式）。

这段代码是建立在其他答案的概念之上的。如果有问题，它的执行速度应该是这里发布的更好的之一。

var decimalCharacter = Number("1.1").toLocaleString().substr(1,1);var defaultCurrencyMarker = "$";function formatCurrency(number, currencyMarker) {if (typeof number != "number")number = parseFloat(number, 10);
// if NaN is passed in or comes from the parseFloat, set it to 0.if (isNaN(number))number = 0;
var sign = number < 0 ? "-" : "";number = Math.abs(number);    // so our signage goes before the $ symbol.
var integral = Math.floor(number);var formattedIntegral = integral.toLocaleString();
// IE returns "##.00" while others return "##"formattedIntegral = formattedIntegral.split(decimalCharacter)[0];
var decimal = Math.round((number - integral) * 100);return sign + (currencyMarker || defaultCurrencyMarker) +formattedIntegral  +decimalCharacter +decimal.toString() + (decimal < 10 ? "0" : "");}

这些测试仅适用于美国语言环境机器。做出这个决定是为了简单，因为这可能导致糟糕的输入（糟糕的自动定位），从而导致糟糕的输出问题。

var tests = [// [ input, expected result ][123123, "$123,123.00"],    // no decimal[123123.123, "$123,123.12"],    // decimal rounded down[123123.126, "$123,123.13"],    // decimal rounded up[123123.4, "$123,123.40"],    // single decimal["123123", "$123,123.00"],    // repeat subset of the above using string input.["123123.123", "$123,123.12"],["123123.126", "$123,123.13"],[-123, "-$123.00"]    // negatives];
for (var testIndex=0; testIndex < tests.length; testIndex++) {var test = tests[testIndex];var formatted = formatCurrency(test[0]);if (formatted == test[1]) {console.log("Test passed, \"" + test[0] + "\" resulted in \"" + formatted + "\"");} else {console.error("Test failed. Expected \"" + test[1] + "\", got \"" + formatted + "\"");}}

小开

适用于所有当前的浏览器

使用toLocaleString格式化货币的语言敏感表示（使用iso4217货币代码）。

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

avenmore的南非兰特代码片段示例：

console.log((2500).toLocaleString("en-ZA", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))// -> R 2 500,00console.log((2500).toLocaleString("en-GB", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))// -> ZAR 2,500.00

小开

以下是将数字转换为货币格式的简短而最佳的方法：

function toCurrency(amount){return amount.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");}
// usage: toCurrency(3939920.3030);

小开

以下是一些解决方案，它们都通过了测试套件。包括测试套件和基准测试。如果您想复制和粘贴进行测试，请尝试这一要点。

方法0（RegExp）

它基于VisioN的回答，但如果没有小数点，它会修复。

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

方法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 '-' signhead = Number(this < 0);
// Skip the digits that's before the first thousands separatorhead += (a[0].length - head) % 3 || 3;
a[0] = a[0].slice(0, head) + a[0].slice(head).replace(/\d{3}/g, ',$&');return a.join('.');};}

方法2（拆分为数组）

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

方法3（循环）

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

用法示例

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

分离器

如果我们想要自定义千分隔符或十进制分隔符，请使用replace()：

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

测试套件

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 paddingassertEqual('1.00', format_function.call(1, 2))assertEqual('-1.00', format_function.call(-1, 2))
// Decimal roundingassertEqual('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 separatorassertEqual('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 decimalassertEqual('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);

基准

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, the browser will stop responding while running.// This will create a new thread to benchmarkasync = [];function next() {setTimeout(function () {f = async.shift();f && f();next();}, 10);}
console.log('======== Benchmark ========');async.push(function () { benchmark_format(Number.prototype.format); });next();

小开

处理货币输出的函数，包括负数。

示例输出：
5.23美元
-5.23美元

function formatCurrency(total) {var neg = false;if(total < 0) {neg = true;total = Math.abs(total);}return (neg ? "-$" : '$') + parseFloat(total, 10).toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, "$1,").toString();}

小开

代码来自Jonathan M对我来说太复杂了，所以我重写了它，在Firefox v30上获得了大约30%，在v35上获得了60%Chrome速度提升（http://jsperf.com/number-formating2）：

Number.prototype.formatNumber = function(decPlaces, thouSeparator, decSeparator) {decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;decSeparator = decSeparator == undefined ? "." : decSeparator;thouSeparator = thouSeparator == undefined ? "," : thouSeparator;
var n = this.toFixed(decPlaces);if (decPlaces) {var i = n.substr(0, n.length - (decPlaces + 1));var j = decSeparator + n.substr(-decPlaces);} else {i = n;j = '';}
function reverse(str) {var sr = '';for (var l = str.length - 1; l >= 0; l--) {sr += str.charAt(l);}return sr;}
if (parseInt(i)) {i = reverse(reverse(i).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator));}return i + j;};

用法：

var sum = 123456789.5698;var formatted = '$' + sum.formatNumber(2, ',', '.'); // "$123,456,789.57"

小开

我喜欢简单：

function formatPriceUSD(price) {var strPrice = price.toFixed(2).toString();var a = strPrice.split('');
if (price > 1000000000)a.splice(a.length - 12, 0, ',');
if (price > 1000000)a.splice(a.length - 9, 0, ',');
if (price > 1000)a.splice(a.length - 6, 0, ',');
return '$' + a.join("");}

小开

int. NumberFormat

var number = 3500;alert(new Intl.NumberFormat().format(number));// → "3,500" if in US English locale

或者PHP在JavaScript中的number_format。

小开

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat示例：使用locales

此示例显示了本地化数字格式的一些变体。为了获取应用程序用户交互界面中使用的语言的格式，请确保使用locales参数指定该语言（可能还有一些备用语言）：

var数=123456.789；

//德语使用逗号作为小数点分隔符，句号表示千console.log（new Intl. NumberFormat（'de-DE'）. Format（)); // →123.456,789

//大多数阿拉伯语国家的阿拉伯语使用真正的阿拉伯数字console.log（new Intl. NumberFormat（'ar-EG'）. Format（)); // →١٢٣٤٥٦٫٧٨٩

//印度使用数千/lakh/克若分离器console.log在tl中。数字格式（'en-IN'）。格式（数字））；

小开

如果金额是一个数字，比如-123，那么

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

将生成字符串"-$123.00"。

这是一个完整的工作示例。

小开

我喜欢最短的VisionN的回答，除非我需要修改一个没有小数点的数字（123美元而不是123美元）。它不起作用，所以我需要破译JavaScript正则表达式的神秘语法，而不是快速复制/粘贴。

这是最初的解决方案

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

我会让它长一点：

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

这里的re部分（字符串替换中的搜索部分）意味着

查找所有数字（\d）
接下来是（?=…）（向前看）
一个或多个组(…)+
三位数（\d{3}）
以点结束（\.）
对所有事件执行此操作（g）

这里的subst是指：

每次有匹配时，将其替换为自身（$&），后跟逗号。

当我们使用string.replace时，字符串中的所有其他文本保持不变，只有找到的数字（后面跟着3、6、9等其他数字的数字）会获得额外的逗号。

因此，在数字1234567.89中，数字1和4满足条件（1234567.89）并被替换为“1、”和“4，”，结果为1,234,567.89。

如果我们根本不需要美元金额的小数点（即123美元而不是123美元），我们可以像这样更改正则表达式：

var re2 = /\d(?=(\d{3})+$)/g;

它依赖于行尾（$）而不是点（\.），最终表达式将是（另请注意toFixed(0)）：

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

这个表达式将给出

1234567.89 -> 1,234,567

此外，在上面的正则表达式中，您可以选择单词边界（\b），而不是行结束（$）。

如果我误解了正则表达式处理的任何部分，我提前道歉。

小开

许多答案都有有用的想法，但没有一个能满足我的需求。所以我使用了所有的想法并建立了这个例子：

function Format_Numb(fmt){var decimals = isNaN(decimals) ? 2 : Math.abs(decimals);if(typeof decSgn === "undefined") decSgn = ".";if(typeof kommaSgn === "undefined") kommaSgn= ",";
var s3digits = /(\d{1,3}(?=(\d{3})+(?=[.]|$))|(?:[.]\d*))/g;var dflt_nk = "00000000".substring(0, decimals);
//--------------------------------// handler for pattern: "%m"var _f_money = function(v_in){var v = v_in.toFixed(decimals);var add_nk = ",00";var arr = v.split(".");return arr[0].toString().replace(s3digits, function ($0) {return ($0.charAt(0) == ".")? ((add_nk = ""), (kommaSgn + $0.substring(1))): ($0 + decSgn);})+ ((decimals > 0)? (kommaSgn+ ((arr.length > 1)? arr[1]: dflt_nk)): "");}
// handler for pattern: "%<len>[.<prec>]f"var _f_flt = function(v_in, l, prec){var v = (typeof prec !== "undefined") ? v_in.toFixed(prec) : v_in;return ((typeof l !== "undefined") && ((l=l-v.length) > 0))? (Array(l+1).join(" ") + v): v;}
// handler for pattern: "%<len>x"var _f_hex = function(v_in, l, flUpper){var v = Math.round(v_in).toString(16);if(flUpper) v = v.toUpperCase();return ((typeof l !== "undefined") && ((l=l-v.length) > 0))? (Array(l+1).join("0") + v): v;}
//...can be extended..., just add the function, for example:    var _f_octal = function( v_in,...){//--------------------------------
if(typeof(fmt) !== "undefined"){//...can be extended..., just add the char, for example "O":    MFX -> MFXOvar rpatt = /(?:%([^%"MFX]*)([MFX]))|(?:"([^"]*)")|("|%%)/gi;var _qu = "\"";var _mask_qu = "\\\"";var str = fmt.toString().replace(rpatt, function($0, $1, $2, $3, $4){var f;if(typeof $1 !== "undefined"){switch($2.toUpperCase()){case "M": f = "_f_money(v)";    break;
case "F": var n_dig0, n_dig1;var re_flt =/^(?:(\d))*(?:[.](\d))*$/;$1.replace(re_flt, function($0, $1, $2){n_dig0 = $1;n_dig1 = $2;});f = "_f_flt(v, " + n_dig0 + "," + n_dig1 + ")";    break;
case "X": var n_dig = "undefined";var re_flt = /^(\d*)$/;$1.replace(re_flt, function($0){if($0 != "") n_dig = $0;});f = "_f_hex(v, " + n_dig + "," + ($2=="X") + ")";    break;//...can be extended..., for example:    case "O":}return "\"+"+f+"+\"";} else if(typeof $3 !== "undefined"){return _mask_qu + $3 + _mask_qu;} else {return ($4 == _qu) ? _mask_qu : $4.charAt(0);}});
var cmd =     "return function(v){"+     "if(typeof v === \"undefined\")return \"\";"  // null returned as empty string+     "if(!v.toFixed) return v.toString();"         // not numb returned as string+     "return \"" + str + "\";"+ "}";
//...can be extended..., just add the function name in the 2 places:return new Function("_f_money,_f_flt,_f_hex", cmd)(_f_money,_f_flt,_f_hex);}}

首先，我需要一个c风格格式字符串定义，它应该是灵活，但非常易于使用，我用以下方式定义它；模式：

%[<len>][.<prec>]f   float, example "%f", "%8.2d", "%.3f"%m                   money%[<len>]x            hexadecimal lower case, example "%x", "%8x"%[<len>]X            hexadecimal upper case, example "%X", "%8X"

因为我不需要格式化其他人而不是欧元，所以我只实现了“%m”。

但这很容易扩展……就像在C中一样，格式字符串是包含模式的字符串。例如，对欧元："%m欧元"（返回像“8.129,33欧元”这样的字符串）

除了灵活性之外，我还需要一个非常快速的表处理解决方案。这意味着，在处理数千个单元格时，处理格式字符串不能做超过一次。我不能接受像“格式（值，fmt）”这样的调用，但这必须分为两步：

// var formatter = Format_Numb( "%m €");// simple example for Euro...
//   but we use a complex example:
var formatter = Format_Numb("a%%%3mxx \"zz\"%8.2f°\"  >0x%8X<");
// formatter is now a function, which can be used more than once (this is an example, that can be tested:)
var v1 = formatter(1897654.8198344);
var v2 = formatter(4.2);
... (and thousands of rows)

同样为了性能，_f_money包含正则表达式；

第三，不能接受像“格式（值，fmt）”这样的调用，因为：

虽然应该可以使用不同的掩码格式化不同的对象集合（例如，列的单元格），但我不想在处理时处理格式化字符串。在这一点上，我只想要来使用格式，就像在

for（单元格中的var单元格）{do_something（cell.col.formatter（cell.value )); }

什么格式-也许它是在. ini文件中定义的，在XML中为每一列或其他地方定义的…，但是分析和设置格式或处理国际化在完全不同的地方加工，我想在不考虑性能问题的情况下将格式化程序分配给集合：

col.formatter=Format_Numb（_getFormatForColumn（.））；

第四，我想要一个“宽容”解决方案，所以传递，例如，一个字符串而不是一个数字应该只返回字符串，但“null”应该返回一个空字符串。

（如果值太大，格式化“%4.2f”也不能剪切某些内容。）

最后，但并非最不重要-它应该是可读且易于扩展，没有对性能有任何影响…例如，如果有人需要“八进制值”，请参考“…可以扩展…”-我认为这应该是一个非常简单的任务。

我的整体重点在于性能。每个“处理例程”（例如，_f_money）都可以封装优化或与这个或其他线程中的其他想法交换，而无需更改“准备例程”（分析格式字符串和创建函数），这些例程必须只处理一次，从这个意义上说，并不像数千个数字的转换调用那样对性能至关重要。

对于所有喜欢数字方法的人：

Number.prototype.format_euro = (function(formatter){return function(){ return formatter(this); }})(Format_Numb( "%m €"));
var v_euro = (8192.3282).format_euro(); // results: 8.192,33 €
Number.prototype.format_hex = (function(formatter){return function(){ return formatter(this); }})(Format_Numb( "%4x"));
var v_hex = (4.3282).format_hex();

虽然我测试了一些，但代码中可能有很多错误。所以它不是一个现成的模块，而只是像我这样的非JavaScript专家的一个想法和起点。

该代码包含了很多Stack Overflow帖子中的很多和很少的修改想法；对不起，我不能引用所有这些，但感谢所有的专家。

小开

已经有了很好的答案。下面是一个简单的尝试：

function currencyFormat(no) {var ar = (+no).toFixed(2).split('.');return [numberFormat(ar[0] | 0),'.',ar[1]].join('');}

function numberFormat(no) {var str = no + '';var ar = [];var i  = str.length -1;
while(i >= 0) {ar.push((str[i-2] || '') + (str[i-1] || '') + (str[i] || ''));i = i-3;}return ar.reverse().join(',');}

然后运行一些示例：

console.log(currencyFormat(1),currencyFormat(1200),currencyFormat(123),currencyFormat(9870000),currencyFormat(12345),currencyFormat(123456.232))

小开

塔格涅是正确的。由于浮点四舍五入，我下面的解决方案不好。toLocaleString函数缺乏一些浏览器支持。我将留下下面的评论，用于归档没有要做的事情。：）

Date.prototype.toLocaleString（）

（旧解决方案）使用Patrick Desjardins的解决方案

这是一个使用toLocaleString（）的简洁解决方案，自JavaScript 1.0版以来一直受到支持。此示例将货币指定为美元，但可以使用“GBP”而不是“USD”切换为英镑。

var formatMoney = function (value) {// Convert the value to a floating point number in case it arrives as a string.var numeric = parseFloat(value);// Specify the local currency.return numeric.toLocaleString('USD', { style: 'currency', currency: "USD", minimumFractionDigits: 2, maximumFractionDigits: 2 });}

见国际化和本地化，货币更多细节。

小开

另一种方式：

function centsToDollaString(x){var cents = x + ""while(cents.length < 4){cents = "0" + cents;}var dollars = cents.substr(0,cents.length - 2)var decimal = cents.substr(cents.length - 2, 2)while(dollars.length % 3 != 0){dollars = "0" + dollars;}str = dollars.replace(/(\d{3})(?=\d)/g, "$1" + ",").replace(/^0*(?=.)/, "");return "$" + str + "." + decimal;}

小开

我想对此做出贡献：

function toMoney(amount) {neg = amount.charAt(0);amount = amount.replace(/\D/g, '');amount = amount.replace(/\./g, '');amount = amount.replace(/\-/g, '');
var numAmount = new Number(amount);amount = numAmount.toFixed(0).replace(/./g, function(c, i, a) {return i > 0 && c !== "," && (a.length - i) % 3 === 0 ? "." + c : c;});
if(neg == '-')return neg + amount;elsereturn amount;}

这允许您在输入框中转换数字，您只应该在其中放置数字（考虑这种情况）。

这将清理一个文本框，其中只有数字，即使您粘贴带有数字和字母或任何字符的字符串

<html><head><script language=="Javascript">function isNumber(evt) {var theEvent = evt || window.event;var key = theEvent.keyCode || theEvent.which;key = String.fromCharCode(key);if (key.length == 0)return;var regex = /^[0-9\-\b]+$/;if (!regex.test(key)) {theEvent.returnValue = false;if (theEvent.preventDefault)theEvent.preventDefault();}}
function toMoney(amount) {neg = amount.charAt(0);amount = amount.replace(/\D/g, '');amount = amount.replace(/\./g, '');amount = amount.replace(/\-/g, '');
var numAmount = new Number(amount);amount = numAmount.toFixed(0).replace(/./g, function(c, i, a) {return i > 0 && c !== "," && (a.length - i) % 3 === 0 ? "." + c : c;});
if(neg == '-')return neg + amount;elsereturn amount;}
function clearText(inTxt, newTxt, outTxt) {inTxt = inTxt.trim();newTxt = newTxt.trim();if(inTxt == '' || inTxt == newTxt)return outTxt;
return inTxt;}
function fillText(inTxt, outTxt) {inTxt = inTxt.trim();if(inTxt != '')outTxt = inTxt;
return outTxt;}</script></head>
<body>$ <input name=reca2 id=reca2 type=text value="0" onFocus="this.value = clearText(this.value, '0', '');" onblur="this.value = fillText(this.value, '0'); this.value = toMoney(this.value);" onKeyPress="isNumber(event);" style="width:80px;" /></body>
</html>

小开

我从accounting.js找到了这个。它非常简单，完全符合我的需要。

// 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 rightaccounting.formatMoney(5318008, {symbol: "€", precision: 2, thousand: ".", decimal : ",", format: "%v%s"}); // 1.008,00€

小开

toLocaleString很好，但它并不适用于所有浏览器。我通常使用currencyFormatter.js（https://osrec.github.io/currencyFormatter.js/）。它非常轻量级，包含了开箱即用的所有货币和语言环境定义。它也擅长格式化格式异常的货币，例如INR（它将lakhs、亿卢比等中的数字分组）。此外，没有任何依赖项！

OSREC.CurrencyFormatter.format(2534234, { currency: 'INR' }); // Returns ₹ 25,34,234.00

OSREC.CurrencyFormatter.format(2534234, { currency: 'EUR' }); // Returns 2.534.234,00 €

OSREC.CurrencyFormatter.format(2534234, { currency: 'EUR', locale: 'fr' }); // Returns 2 534 234,00 €

小开

以下内容简洁易懂，不依赖任何过于复杂的正则表达式。

function moneyFormat(price, sign = '$') {const pieces = parseFloat(price).toFixed(2).split('')let ii = pieces.length - 3while ((ii-=3) > 0) {pieces.splice(ii, 0, ',')}return sign + pieces.join('')}
console.log(moneyFormat(100),moneyFormat(1000),moneyFormat(10000.00),moneyFormat(1000000000000000000))

这是一个在最终输出中具有更多选项的版本，允许以不同的本地格式格式化不同的货币。

// higher order function that takes options then a price and will return the formatted priceconst makeMoneyFormatter = ({sign = '$',delimiter = ',',decimal = '.',append = false,precision = 2,round = true,custom} = {}) => value => {
const e = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]
value = round? (Math.round(value * e[precision]) / e[precision]): parseFloat(value)
const pieces = value.toFixed(precision).replace('.', decimal).split('')
let ii = pieces.length - (precision ? precision + 1 : 0)
while ((ii-=3) > 0) {pieces.splice(ii, 0, delimiter)}
if (typeof custom === 'function') {return custom({sign,float: value,value: pieces.join('')})}
return append? pieces.join('') + sign: sign + pieces.join('')}
// create currency converters with the correct formatting optionsconst formatDollar = makeMoneyFormatter()const formatPound = makeMoneyFormatter({sign: '£',precision: 0})const formatEuro = makeMoneyFormatter({sign: '€',delimiter: '.',decimal: ',',append: true})
const customFormat = makeMoneyFormatter({round: false,custom: ({ value, float, sign }) => `SALE:$${value}USD`})
console.log(formatPound(1000),formatDollar(10000.0066),formatEuro(100000.001),customFormat(999999.555))

小开

我很难找到一个简单的库来处理日期和货币，所以我创建了自己的：https://github.com/dericeira/slimFormatter.js

就这么简单：

var number = slimFormatter.currency(2000.54);

小开

这是vanilla JavaScript中一个简单的格式化程序：

function numberFormatter (num) {console.log(num)var wholeAndDecimal = String(num.toFixed(2)).split(".");console.log(wholeAndDecimal)var reversedWholeNumber = Array.from(wholeAndDecimal[0]).reverse();var formattedOutput = [];
reversedWholeNumber.forEach( (digit, index) => {formattedOutput.push(digit);if ((index + 1) % 3 === 0 && index < reversedWholeNumber.length - 1) {formattedOutput.push(",");}})
formattedOutput = formattedOutput.reverse().join('') + "." + wholeAndDecimal[1];
return formattedOutput;}

小开

因为每个问题都需要一个单行解决方案：

Number.prototype.formatCurrency = function() { return this.toFixed(2).toString().split(/[-.]/).reverse().reduceRight(function (t, c, i) { return (i == 2) ? '-' + t : (i == 1) ? t + c.replace(/(\d)(?=(\d{3})+$)/g, '$1,') : t + '.' + c; }, '$'); }

这很容易针对不同的地区进行更改。只需将“1美元”更改为“1美元”和“.”更改为“，”即可交换数字,和.。货币符号可以通过更改末尾的“$”来更改。

或者，如果你有ES6，你可以用默认值声明函数：

Number.prototype.formatCurrency = function(thou = ',', dec = '.', sym = '$') { return this.toFixed(2).toString().split(/[-.]/).reverse().reduceRight(function (t, c, i) { return (i == 2) ? '-' + t : (i == 1) ? t + c.replace(/(\d)(?=(\d{3})+$)/g, '$1' + thou) : t + dec + c; }, sym); }
console.log((4215.57).formatCurrency())$4,215.57console.log((4216635.57).formatCurrency('.', ','))$4.216.635,57console.log((4216635.57).formatCurrency('.', ',', "\u20AC"))€4.216.635,57

哦，它也适用于负数：

console.log((-6635.574).formatCurrency('.', ',', "\u20AC"))-€6.635,57console.log((-1066.507).formatCurrency())-$1,066.51

当然，你不必有货币符号：

console.log((1234.586).formatCurrency(',','.',''))1,234.59console.log((-7890123.456).formatCurrency(',','.',''))-7,890,123.46console.log((1237890.456).formatCurrency('.',',',''))1.237.890,46

小开

我想要一个自动返回小数部分的香草JavaScript解决方案。

function formatDollar(amount) {var dollar = Number(amount).toLocaleString("us", "currency");// Decimalsvar arrAmount = dollar.split(".");if (arrAmount.length==2) {var decimal = arrAmount[1];if (decimal.length==1) {arrAmount[1] += "0";}}if (arrAmount.length==1) {arrAmount.push("00");}
return "$" + arrAmount.join(".");}

console.log(formatDollar("1812.2");

小开

Number(value).toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")

小开

请在下面的代码中找到我为支持国际化而开发的内容。

它将给定的数值格式化为特定于语言的格式。在给定的示例中，我使用了'en'，同时测试了'es'、“fr”和其他格式不同的国家/地区。它不仅阻止用户键入字符，而且还格式化了制表符上的值。

我已经为数量和十进制格式创建了组件。除此之外，我还创建了parseNumber（value， locale）和parseDecimal（值，区域设置）函数，它们将解析格式化数据以用于任何其他业务目的。所述函数将接受格式化数据并返回未格式化的值。我在下面的共享代码中使用了jQuery验证器插件。

超文本标记语言：

<tr><td><label class="control-label">Number Field:</label><div class="inner-addon right-addon"><input type="text" id="numberField"name="numberField"class="form-control"autocomplete="off"maxlength="17"data-rule-required="true"data-msg-required="Cannot be blank."data-msg-maxlength="Exceeding the maximum limit of 13 digits. Example: 1234567890123"data-rule-numberExceedsMaxLimit="en"data-msg-numberExceedsMaxLimit="Exceeding the maximum limit of 13 digits. Example: 1234567890123"onkeydown="return isNumber(event, 'en')"onkeyup="return updateField(this)"onblur="numberFormatter(this,'en','Invalid character(s) found. Please enter valid characters.')"></div></td></tr>
<tr><td><label class="control-label">Decimal Field:</label><div class="inner-addon right-addon"><input type="text" id="decimalField"name="decimalField"class="form-control"autocomplete="off"maxlength="20"data-rule-required="true"data-msg-required="Cannot be blank."data-msg-maxlength="Exceeding the maximum limit of 16 digits. Example: 1234567890123.00"data-rule-decimalExceedsMaxLimit="en"data-msg-decimalExceedsMaxLimit="Exceeding the maximum limit of 16 digits. Example: 1234567890123.00"onkeydown="return isDecimal(event, 'en')"onkeyup="return updateField(this)"onblur="decimalFormatter(this,'en','Invalid character(s) found. Please enter valid characters.')"></div></td></tr>

JavaScript：

/** @author: dinesh.lomte*//* Holds the maximum limit of digits to be entered in number field. */var numericMaxLimit = 13;/* Holds the maximum limit of digits to be entered in decimal field. */var decimalMaxLimit = 16;
/**** @param {type} value* @param {type} locale* @returns {Boolean}*/parseDecimal = function(value, locale) {
value = value.trim();if (isNull(value)) {return 0.00;}if (isNull(locale)) {return value;}if (getNumberFormat(locale)[0] === '.') {value = value.replace(/\./g, '');} else {value = value.replace(new RegExp(getNumberFormat(locale)[0], 'g'), '');}if (getNumberFormat(locale)[1] === ',') {value = value.replace(new RegExp(getNumberFormat(locale)[1], 'g'), '.');}return value;};
/**** @param {type} element* @param {type} locale* @param {type} nanMessage* @returns {Boolean}*/decimalFormatter = function (element, locale, nanMessage) {
showErrorMessage(element.id, false, null);if (isNull(element.id) || isNull(element.value) || isNull(locale)) {return true;}var value = element.value.trim();value = value.replace(/\s/g, '');value = parseDecimal(value, locale);var numberFormatObj = new Intl.NumberFormat(locale,{   minimumFractionDigits: 2,maximumFractionDigits: 2});if (numberFormatObj.format(value) === 'NaN') {showErrorMessage(element.id, true, nanMessage);setFocus(element.id);return false;}element.value = numberFormatObj.format(value);return true;};
/**** @param {type} element* @param {type} locale* @param {type} nanMessage* @returns {Boolean}*/numberFormatter = function (element, locale, nanMessage) {
showErrorMessage(element.id, false, null);if (isNull(element.id) || isNull(element.value) || isNull(locale)) {return true;}var value = element.value.trim();var format = getNumberFormat(locale);if (hasDecimal(value, format[1])) {showErrorMessage(element.id, true, nanMessage);setFocus(element.id);return false;}value = value.replace(/\s/g, '');value = parseNumber(value, locale);var numberFormatObj = new Intl.NumberFormat(locale,{   minimumFractionDigits: 0,maximumFractionDigits: 0});if (numberFormatObj.format(value) === 'NaN') {showErrorMessage(element.id, true, nanMessage);setFocus(element.id);return false;}element.value =numberFormatObj.format(value);return true;};
/**** @param {type} id* @param {type} flag* @param {type} message* @returns {undefined}*/showErrorMessage = function(id, flag, message) {
if (flag) {// only add if not addedif ($('#'+id).parent().next('.app-error-message').length === 0) {var errorTag = '<div class=\'app-error-message\'>' + message + '</div>';$('#'+id).parent().after(errorTag);}} else {// remove it$('#'+id).parent().next(".app-error-message").remove();}};
/**** @param {type} id* @returns*/setFocus = function(id) {
id = id.trim();if (isNull(id)) {return;}setTimeout(function() {document.getElementById(id).focus();}, 10);};
/**** @param {type} value* @param {type} locale* @returns {Array}*/parseNumber = function(value, locale) {
value = value.trim();if (isNull(value)) {return 0;}if (isNull(locale)) {return value;}if (getNumberFormat(locale)[0] === '.') {return value.replace(/\./g, '');}return value.replace(new RegExp(getNumberFormat(locale)[0], 'g'), '');};
/**** @param {type} locale* @returns {Array}*/getNumberFormat = function(locale) {
var format = [];var numberFormatObj = new Intl.NumberFormat(locale,{   minimumFractionDigits: 2,maximumFractionDigits: 2});var value = numberFormatObj.format('132617.07');format[0] = value.charAt(3);format[1] = value.charAt(7);return format;};
/**** @param {type} value* @param {type} fractionFormat* @returns {Boolean}*/hasDecimal = function(value, fractionFormat) {
value = value.trim();if (isNull(value) || isNull(fractionFormat)) {return false;}if (value.indexOf(fractionFormat) >= 1) {return true;}};
/**** @param {type} event* @param {type} locale* @returns {Boolean}*/isNumber = function(event, locale) {
var keyCode = event.which ? event.which : event.keyCode;// Validating if user has pressed shift characterif (keyCode === 16) {return false;}if (isNumberKey(keyCode)) {return true;}var numberFormatter = [32, 110, 188, 190];if (keyCode === 32&& isNull(getNumberFormat(locale)[0]) === isNull(getFormat(keyCode))) {return true;}if (numberFormatter.indexOf(keyCode) >= 0&& getNumberFormat(locale)[0] === getFormat(keyCode)) {return true;}return false;};
/**** @param {type} event* @param {type} locale* @returns {Boolean}*/isDecimal = function(event, locale) {
var keyCode = event.which ? event.which : event.keyCode;// Validating if user has pressed shift characterif (keyCode === 16) {return false;}if (isNumberKey(keyCode)) {return true;}var numberFormatter = [32, 110, 188, 190];if (keyCode === 32&& isNull(getNumberFormat(locale)[0]) === isNull(getFormat(keyCode))) {return true;}if (numberFormatter.indexOf(keyCode) >= 0&& (getNumberFormat(locale)[0] === getFormat(keyCode)|| getNumberFormat(locale)[1] === getFormat(keyCode))) {return true;}return false;};
/**** @param {type} keyCode* @returns {Boolean}*/isNumberKey = function(keyCode) {
if ((keyCode >= 48 && keyCode <= 57) ||(keyCode >= 96 && keyCode <= 105)) {return true;}var keys = [8, 9, 13, 35, 36, 37, 39, 45, 46, 109, 144, 173, 189];if (keys.indexOf(keyCode) !== -1) {return true;}return false;};
/**** @param {type} keyCode* @returns {JSON@call;parse.numberFormatter.value|String}*/getFormat = function(keyCode) {
var jsonString = '{"numberFormatter" : [{"key":"32", "value":" ", "description":"space"}, {"key":"188", "value":",", "description":"comma"}, {"key":"190", "value":".", "description":"dot"}, {"key":"110", "value":".", "description":"dot"}]}';var jsonObject = JSON.parse(jsonString);for (var key in jsonObject.numberFormatter) {if (jsonObject.numberFormatter.hasOwnProperty(key)&& keyCode === parseInt(jsonObject.numberFormatter[key].key)) {return jsonObject.numberFormatter[key].value;}}return '';};
/**** @type String*/var jsonString = '{"shiftCharacterNumberMap" : [{"char":")", "number":"0"}, {"char":"!", "number":"1"}, {"char":"@", "number":"2"}, {"char":"#", "number":"3"}, {"char":"$", "number":"4"}, {"char":"%", "number":"5"}, {"char":"^", "number":"6"}, {"char":"&", "number":"7"}, {"char":"*", "number":"8"}, {"char":"(", "number":"9"}]}';
/**** @param {type} value* @returns {JSON@call;parse.shiftCharacterNumberMap.number|String}*/getShiftCharSpecificNumber = function(value) {
var jsonObject = JSON.parse(jsonString);for (var key in jsonObject.shiftCharacterNumberMap) {if (jsonObject.shiftCharacterNumberMap.hasOwnProperty(key)&& value === jsonObject.shiftCharacterNumberMap[key].char) {return jsonObject.shiftCharacterNumberMap[key].number;}}return '';};
/**** @param {type} value* @returns {Boolean}*/isShiftSpecificChar = function(value) {
var jsonObject = JSON.parse(jsonString);for (var key in jsonObject.shiftCharacterNumberMap) {if (jsonObject.shiftCharacterNumberMap.hasOwnProperty(key)&& value === jsonObject.shiftCharacterNumberMap[key].char) {return true;}}return false;};
/**** @param {type} element* @returns {undefined}*/updateField = function(element) {
var value = element.value;
for (var index = 0; index < value.length; index++) {if (!isShiftSpecificChar(value.charAt(index))) {continue;}element.value = value.replace(value.charAt(index),getShiftCharSpecificNumber(value.charAt(index)));}};
/**** @param {type} value* @param {type} element* @param {type} params*/jQuery.validator.addMethod('numberExceedsMaxLimit', function(value, element, params) {
value = parseInt(parseNumber(value, params));if (value.toString().length > numericMaxLimit) {showErrorMessage(element.id, false, null);setFocus(element.id);return false;}return true;}, 'Exceeding the maximum limit of 13 digits. Example: 1234567890123.');
/**** @param {type} value* @param {type} element* @param {type} params*/jQuery.validator.addMethod('decimalExceedsMaxLimit', function(value, element, params) {
value = parseFloat(parseDecimal(value, params)).toFixed(2);if (value.toString().substring(0, value.toString().lastIndexOf('.')).length > numericMaxLimit|| value.toString().length > decimalMaxLimit) {showErrorMessage(element.id, false, null);setFocus(element.id);return false;}return true;}, 'Exceeding the maximum limit of 16 digits. Example: 1234567890123.00.');
/*** @param {type} id* @param {type} locale* @returns {boolean}*/isNumberExceedMaxLimit = function(id, locale) {
var value = parseInt(parseNumber(document.getElementById(id).value, locale));if (value.toString().length > numericMaxLimit) {setFocus(id);return true;}return false;};
/*** @param {type} id* @param {type} locale* @returns {boolean}*/isDecimalExceedsMaxLimit = function(id, locale) {
var value = parseFloat(parseDecimal(document.getElementById(id).value, locale)).toFixed(2);if (value.toString().substring(0, value.toString().lastIndexOf('.')).length > numericMaxLimit|| value.toString().length > decimalMaxLimit) {setFocus(id);return true;}return false;};

小开

我们也可以使用数字js

可以将数字格式化为货币、百分比、时间，甚至是带有小数位、千位和缩写的普通旧数字。您始终可以创建自定义格式。

var string = numeral(1000).format('0,0');// '1,000'

小开

请尝试以下代码

"250000".replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1,');

Ans:250,000

小开

我选择了几个评分最高的答案，合并并制作了一个ECMAScript 2015（ES6）函数，它通过了ESLint。

export const formatMoney = (amount,decimalCount = 2,decimal = '.',thousands = ',',currencySymbol = '$',) => {if (typeof Intl === 'object') {return new Intl.NumberFormat('en-AU', {style: 'currency',currency: 'AUD',}).format(amount);}// Fallback if Intl is not present.try {const negativeSign = amount < 0 ? '-' : '';const amountNumber = Math.abs(Number(amount) || 0).toFixed(decimalCount);const i = parseInt(amountNumber, 10).toString();const j = i.length > 3 ? i.length % 3 : 0;return (currencySymbol +negativeSign +(j ? i.substr(0, j) + thousands : '') +i.substr(j).replace(/(\d{3})(?=\d)/g, `$1${thousands}`) +(decimalCount? decimal +Math.abs(amountNumber - i).toFixed(decimalCount).slice(2): ''));} catch (e) {// eslint-disable-next-line no-consoleconsole.error(e);}return amount;};

小开

只需使用原生javascript Intl

您只需使用选项来格式化其值

const number = 1233445.5678console.log(new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(number));

mozilla留档链接

小开

在将PHPnumber_format（）转换为JavaScript后，这项工作对我来说

function number_format(number, decimals = 0, dec_point = ".",thousands_sep = ",") {number = (number + '').replace(/[^0-9+\-Ee.]/g, '');var n = !isFinite(+number) ? 0 : +number,prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),s = '',toFixedFix = function(n, prec){var k = Math.pow(10, prec);return '' + (Math.round(n * k) / k).toFixed(prec);};// Fix for IE parseFloat(0.55).toFixed(0) = 0;s = (prec ? toFixedFix(n, prec) : '' +Math.round(n)).split('.');if (s[0].length > 3){s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g,thousands_sep);}if ((s[1] || '').length < prec){s[1] = s[1] || '';s[1] += new Array(prec - s[1].length + 1).join('0');}return s.join(dec_point);}