如何使用逗号作为千位分隔符在JavaScript中打印数字

Elias Zamaria 1589 javascript formatting numbers

我试图用逗号作为千位分隔符在JavaScript中打印一个整数.例如,我想将数字1234567显示为"1,234,567".我该怎么做呢?

我是这样做的:

function numberWithCommas(x) {
    x = x.toString();
    var pattern = /(-?\d+)(\d{3})/;
    while (pattern.test(x))
        x = x.replace(pattern, "$1,$2");
    return x;
}

有更简单或更优雅的方式吗?如果它也适用于浮点数会很好,但这不是必需的.它不需要特定于语言环境来决定句点和逗号.

Elias Zamari.. 2597

我使用了克里答案中的想法,但简化了它,因为我只是为了我的特定目的而寻找简单的东西.这是我做的:

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

这是你真正需要知道的.

@Neils Bom询问了正则表达式的工作原理.我的解释有点长.它不适合评论,我不知道在哪里放,所以我在这里做.如果有人有任何其他建议,请告诉我.

正则表达式使用2个前瞻断言:一个正向查找字符串中的任何一个点,后面有一个3位数的倍数,以及一个负断言,以确保该点只有3个数字的倍数.替换表达式在那里放一个逗号.

例如,如果你传递它"123456789.01",正断言将匹配7左边的每个点(因为"789"是3位数的倍数,"678"是3位数的倍数,"567",等等.).否定断言检查3位数的倍数后面没有任何数字."789"之后有一段时间,所以它正好是3位数的倍数,所以逗号就在那里."678"是3位数的倍数,但它后面有一个"9",所以这3个数字是一组4的一部分,逗号不会去那里.同样对于"567"."456789"是6位数,是3的倍数,所以在此之前使用逗号."345678"是3的倍数,但它后面有一个"9",所以没有逗号.等等."\ B"

@ neu-rah提到如果小数点后面有3位以上的数字,这个函数会在不受欢迎的地方添加逗号.如果这是一个问题,您可以使用此功能:

function numberWithCommas(x) {
    var parts = x.toString().split(".");
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
    return parts.join(".");
}

  • 尝试numberWithCommas(12345.6789) - >"12,345.6,789"我不喜欢它 (56认同)
  • 这太棒了!感谢您将Kerry的答案提炼到我所需要的.谢谢!对于我最初的工作,这是一个更优雅的解决方案. (35认同)
  • 在"."之后修复的小改进.问题'123456789.01234'.replace(/\B(?=(?=\d*\.)(\ d {3})+(?!\ d))/ g,'_') (28认同)
  • 非常酷,但是注意到它在小数点后面有超过3个位置的数字有问题. (19认同)
  • @DmitrijGolubev不适用于整数.也许强制小数点将是解决方案. (7认同)
  • 它对分数不起作用,我们不希望在小数点后有逗号 (4认同)
  • Intl.NumberFormat()似乎更新一点,因为它使用locale doodads. (4认同)
  • @ yar1如果您打算在Safari中使用它,该怎么办?然后你只需要没有逗号就可以得到号码. (3认同)
  • 那好美丽 (2认同)
  • 附加一个空字符串而不是调用.toString()通常会快一点,所以你可以__return(x +'').replace(/\B(?=(\ d {3})+(?!\ d))/g,','); __如果你传递null或undefined也不会抛出JS错误,但是类型转换确实意味着你将__undefined__转换为字符串'undefined'等等,这是值得注意的. (2认同)
  • 我会做一个追加vs .toString()的快速jsfiddle,但其他人先到了!如果你很好奇http://jsperf.com/tostring-vs-appending-empty-string/3 (2认同)

uKolka.. 1603

我很惊讶没人提到Number.prototype.toLocaleString.它是在JavaScript 1.5(1999年推出)中实现的,因此基本上支持主流浏览器.

var n = 34523453.345
n.toLocaleString()
"34,523,453.345"

通过包含Intl,它也适用于v0.12的Node.js

注意这个函数返回字符串而不是数字

如果你想要不同的东西,Numeral.js可能会很有趣.

  • 似乎在Safari中也不起作用. (50认同)
  • 根据具体情况,性能差异可能是也可能不是问题.如果用于1000个结果的巨型表格,那么它将更重要,但如果仅用于单个值,则差异可以忽略不计.但优点是它具有区域设置意识,因此欧洲有人会看到_34.523.453,345_或_34 523 453,345_.这对于来自许多国家/地区的访问者来说更为重要. (20认同)
  • googlers的更新:`toLocaleString`通过[包含Intl](https://github.com/nodejs/node-v0.x-archive/pull/7719)在v0.12中的Node.js中工作. (20认同)
  • @csigrist好点,但它没有看起来那么糟糕.速度取决于浏览器.在FF或Opera中它表现良好.我虽然糟透了Chrome.至于零:`var number = 123456.000; number.toLocaleString('en-US',{minimumFractionDigits:2}); "123,456.00"`这些选项在FF或Safari中不起作用. (17认同)
  • @MSC你应该尝试`parseInt("1234567",10).toLocaleString('en-US',{minimumFractionDigits:2})`或`new Number("1234567").toLocaleString('en-US',{minimumFractionDigits :2})`而不是.它不起作用,因为你在字符串上使用它,而不是数字. (6认同)
  • 真棒.最后回答本机功能.而且,这个在不同的国家有不同的分隔符显示(在捷克共和国,我们写'X XXX XXX,YYY`). (4认同)
  • 我投了赞成票,但经过进一步研究发现这个答案存在一些问题.性能不如正则表达式格式化程序.请参阅以下链接:http://jsperf.com/number-formatting-with-commas.同时尝试将尾随零作为小数位也是有问题的. (2认同)
  • 这不适用于iPhone上的Chrome或Safari. (2认同)
  • 对于`var n = 12345.54321`,Chrome打印`12,345.543`没有2位小数. (2认同)

vsync.. 222

var number = 1234567890; // Example number to be converted

⚠请注意,javascript的最大整数值为9007199254740991


toLocaleString:

number.toLocaleString(); // "1,234,567,890"

// A more complex example: 
var number2 = 1234.56789; // floating point example
number2.toLocaleString(undefined, {maximumFractionDigits:2}) // "1,234.57"


NumberFormat(不支持 Safari):

var nf = new Intl.NumberFormat();
nf.format(number); // "1,234,567,890"

根据我的检查(至少是Firefox),它们在性能方面或多或少相同.

  • 对于那些在那里实施的人,Safari不支持NumberFormat. (6认同)
  • 在safari上也不支持toLocaleString (6认同)
  • 基本的`toLocaleString`适用于safari,选项不适用 (5认同)
  • 浏览器支持始终在每个MDN页面的底部提及,我已链接到该页面. (3认同)
  • `toLocaleString`解决方案可能还应该包含所需的语言环境,所以`toLocaleString("en")`,因为英语模式使用逗号.但是,如果没有语言环境指示符的`toLocaleString()`在法国运行,那么它将产生句号而不是逗号,因为这是用于在本地分离数千个的. (3认同)

Kerry Jones.. 104

我建议使用phpjs.org的number_format()

function number_format(number, decimals, dec_point, thousands_sep) {
    // http://kevin.vanzonneveld.net
    // +   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)
    // +   improved by: Theriault
    // +   improved by: Drew Noakes
    // *     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'
    var n = !isFinite(+number) ? 0 : +number, 
        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
        toFixedFix = function (n, prec) {
            // Fix for IE parseFloat(0.55).toFixed(0) = 0;
            var k = Math.pow(10, prec);
            return Math.round(n * k) / k;
        },
        s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
    if (s[0].length > 3) {
        s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, 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);
}

更新02/13/14

人们一直在报道这不能按预期工作,所以我做了一个包含自动化测试的JS小提琴.

更新于26/11/2017

这是一个小提琴作为一个略有修改输出的Stack Snippet:

function number_format(number, decimals, dec_point, thousands_sep) {
    // http://kevin.vanzonneveld.net
    // +   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)
    // +   improved by: Theriault
    // +   improved by: Drew Noakes
    // *     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'
    var n = !isFinite(+number) ? 0 : +number, 
        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
        toFixedFix = function (n, prec) {
            // Fix for IE parseFloat(0.55).toFixed(0) = 0;
            var k = Math.pow(10, prec);
            return Math.round(n * k) / k;
        },
        s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
    if (s[0].length > 3) {
        s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, 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);
}

var exampleNumber = 1;
function test(expected, number, decimals, dec_point, thousands_sep)
{
    var actual = number_format(number, decimals, dec_point, thousands_sep);
    console.log(
        'Test case ' + exampleNumber + ': ' +
        '(decimals: ' + (typeof decimals === 'undefined' ? '(default)' : decimals) +
        ', dec_point: "' + (typeof dec_point === 'undefined' ? '(default)' : dec_point) + '"' +
        ', thousands_sep: "' + (typeof thousands_sep === 'undefined' ? '(default)' : thousands_sep) + '")'
    );
    console.log('  => ' + (actual === expected ? 'Passed' : 'FAILED') + ', got "' + actual + '", expected "' + expected + '".');
    exampleNumber++;
}

test('1,235',    1234.56);
test('1 234,56', 1234.56, 2, ',', ' ');
test('1234.57',  1234.5678, 2, '.', '');
test('67,00',    67, 2, ',', '.');
test('1,000',    1000);
test('67.31',    67.311, 2);
test('1,000.6',  1000.55, 1);
test('67.000,00000', 67000, 5, ',', '.');
test('1',        0.9, 0);
test('1.20',     '1.20', 2);
test('1.2000',   '1.20', 4);
test('1.200',    '1.2000', 3);
.as-console-wrapper {
  max-height: 100% !important;
}

  • @ernix - 运营商要求JavaScript,我给出的答案是*JavaScript.这是PHP函数的JavaScript解释. (12认同)
  • @ernix - 好的,但问题是它确实*确切地说是OP所要求的.它来自另一个站点(不是由我维护,我之前已经说过),并且在给出适当的变量时,它的工作方式完全如上所述.如果您认为这是一个错误,请联系phpjs.org或查看他们是否有更新版本. (4认同)
  • @Andrew S - 只有一个人将其标记下来.它确实有效,我已多次在我自己的代码中使用它.它也不是我的代码(也不是我的测试),我引用了它来自的网站,这是一个众所周知的网站.也许他们有更新版本)因为您正在查看的代码是3年. (3认同)
  • @ernix - 它与OP给出的示例完全一样.我放了一个小提琴,你可以看到. (2认同)

小智.. 70

这是@ mikez302的答案的变体,但修改为支持带小数的数字(根据@ neu-rah的反馈,numberWithCommas(12345.6789) - >"12,345.6,789"而不是"12,345.6789"

function numberWithCommas(n) {
    var parts=n.toString().split(".");
    return parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",") + (parts[1] ? "." + parts[1] : "");
}


Tutankhamen.. 63

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

print(formatNumber(2665));      // 2,665
print(formatNumber(102665));    // 102,665
print(formatNumber(111102665)); // 111,102,665

  • 它更短:) (8认同)
  • 这很优雅.正是我在寻找什么. (4认同)
  • 来自http://blog.tompawlak.org/number-currency-formatting-javascript?已知问题:formatNumber(0.123456)= 0.123,456 JS中没有lookbehind使得用优雅的正则表达式修复它很困难. (4认同)

Tính Ngô Qua.. 49

使用正则表达式

function toCommas(value) {
    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}
console.log(toCommas(123456789)); // 123,456,789

console.log(toCommas(1234567890)); // 1,234,567,890
console.log(toCommas(1234)); // 1,234

使用toLocaleString()

var number = 123456.789;

// request a currency format
console.log(number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
// ? 123.456,79 €

// the Japanese yen doesn't use a minor unit
console.log(number.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))
// ? ?123,457

// limit to three significant digits
console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
// ? 1,23,000

ref MDN:Number.prototype.toLocaleString()

使用Intl.NumberFormat()

var number = 123456.789;

console.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(number));
// expected output: "123.456,79 €"

// the Japanese yen doesn't use a minor unit
console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(number));
// expected output: "?123,457"

// limit to three significant digits
console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(number));

// expected output: "1,23,000"

ref Intl.NumberFormat

在这里演示

<script type="text/javascript">
  // Using Regular expression
  function toCommas(value) {
    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  }

  function commas() {
    var num1 = document.myform.number1.value;

    // Using Regular expression
    document.getElementById('result1').value = toCommas(parseInt(num1));
    // Using toLocaleString()

    document.getElementById('result2').value = parseInt(num1).toLocaleString('ja-JP', {
      style: 'currency',
      currency: 'JPY'
    });

    // Using Intl.NumberFormat()
    document.getElementById('result3').value = new Intl.NumberFormat('ja-JP', {
      style: 'currency',
      currency: 'JPY'
    }).format(num1);
  }
</script>
<FORM NAME="myform">
  <INPUT TYPE="text" NAME="number1" VALUE="123456789">
  <br>
  <INPUT TYPE="button" NAME="button" Value="=>" onClick="commas()">
  <br>Using Regular expression
  <br>
  <INPUT TYPE="text" ID="result1" NAME="result1" VALUE="">
  <br>Using toLocaleString()
  <br>
  <INPUT TYPE="text" ID="result2" NAME="result2" VALUE="">
  <br>Using Intl.NumberFormat()
  <br>
  <INPUT TYPE="text" ID="result3" NAME="result3" VALUE="">

</FORM>

性能

性能 http://jsben.ch/sifRd


Dustin Sun.. 36

Intl.NumberFormat

原生JS功能.支持IE11,Edge,最新的Safari,Chrome,Firefox,Opera,iOS上的Safari和Android上的Chrome.

var number = 3500;

console.log(new Intl.NumberFormat().format(number));
// ? '3,500' if in US English locale


J.Money.. 32

感谢大家的回复.我已经建立了一些答案,以制定更"一刀切"的解决方案.

第一个代码段补充说,模仿功能PHPnumber_format()到数字样机.如果我格式化一个数字,我通常需要小数位,所以该函数需要显示小数位数.有些国家使用逗号作为十进制和小数作为千位分隔符,因此该函数允许设置这些分隔符.

Number.prototype.numberFormat = function(decimals, dec_point, thousands_sep) {
    dec_point = typeof dec_point !== 'undefined' ? dec_point : '.';
    thousands_sep = typeof thousands_sep !== 'undefined' ? thousands_sep : ',';

    var parts = this.toFixed(decimals).split('.');
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousands_sep);

    return parts.join(dec_point);
}

您将使用如下:

var foo = 5000;
console.log(foo.numberFormat(2)); // us format: 5,000.00
console.log(foo.numberFormat(2, ',', '.')); // european format: 5.000,00

我发现我经常需要为数学运算取回数字,但是parseFloat将5,000转换为5,只需取第一个整数值序列.所以我创建了自己的浮点转换函数并将其添加到String原型中.

String.prototype.getFloat = function(dec_point, thousands_sep) {
    dec_point = typeof dec_point !== 'undefined' ? dec_point : '.';
    thousands_sep = typeof thousands_sep !== 'undefined' ? thousands_sep : ',';

    var parts = this.split(dec_point);
    var re = new RegExp("[" + thousands_sep + "]");
    parts[0] = parts[0].replace(re, '');

    return parseFloat(parts.join(dec_point));
}

现在您可以使用以下两个函数:

var foo = 5000;
var fooString = foo.numberFormat(2); // The string 5,000.00
var fooFloat = fooString.getFloat(); // The number 5000;

console.log((fooString.getFloat() + 1).numberFormat(2)); // The string 5,001.00

  • @ J.Money .toString是不必要的,toFixed已经返回一个字符串. (3认同)
  • 很好,我借用了第一种方法;)但是,当您要使用欧洲格式并且数字是小数时,它不会产生正确的结果。第5行应为:“ var parts = this.toFixed(decimals).toString()。split('。');” (2认同)

user3664916.. 22

我认为这是最短的正则表达式:

/\B(?=(\d{3})+\b)/g

"123456".replace(/\B(?=(\d{3})+\b)/g, ",")

我检查了几个数字,它工作.


Sinan.. 19

Number.prototype.toLocaleString()如果它是由所有浏览器(Safari)本地提供的话会很棒.

我检查了所有其他答案,但似乎没有人填充它.这是对此的poc,实际上是前两个答案的组合; 如果toLocaleString工作它使用它,如果它不使用它使用自定义功能.

var putThousandsSeparators;

putThousandsSeparators = function(value, sep) {
  if (sep == null) {
    sep = ',';
  }
  // check if it needs formatting
  if (value.toString() === value.toLocaleString()) {
    // split decimals
    var parts = value.toString().split('.')
    // format whole numbers
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, sep);
    // put them back together
    value = parts[1] ? parts.join('.') : parts[0];
  } else {
    value = value.toLocaleString();
  }
  return value;
};

alert(putThousandsSeparators(1234567.890));


phette23.. 17

可以使用浏览器的Intl对象以国际友好的方式插入千位分隔符:

Intl.NumberFormat().format(1234);
// returns "1,234" if the user's locale is en_US, for example

有关更多内容,请参阅MDN关于NumberFormat的文章,您可以指定区域设置行为或默认为用户的行为.这更加万无一失,因为它尊重当地的差异; 许多国家/地区使用句点来分隔数字,而逗号表示小数.

Intl.NumberFormat尚未在所有浏览器中提供,但它适用于最新的Chrome,Opera和IE.Firefox的下一个版本应该支持它.Webkit似乎没有实现的时间表.

  • 虽然如果我们可以使用一个简单的内置函数,这将是非常棒的,它有可怕的浏览器实现.例如,IE 8-10和所有Safari都不支持此功能 (2认同)

Dulith De Co.. 16

您可以使用此过程来格式化您需要的货币.

var nf = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
  minimumFractionDigits: 2,
  maximumFractionDigits: 2
});
nf.format(123456.789); // ‘$123,456.79’

有关详细信息,您可以访问此链接.

https://www.justinmccandless.com/post/formatting-currency-in-javascript/


Shital Shah.. 13

如果你正在处理货币值和格式化很多,那么可能值得添加处理大量边缘情况和本地化的微小accounting.js:

// Default usage:
accounting.formatMoney(12345678); // $12,345,678.00

// European formatting (custom symbol and separators), could also use options object as second param:
accounting.formatMoney(4999.99, "€", 2, ".", ","); // €4.999,99

// Negative values are formatted nicely, too:
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


小智.. 12

以下代码使用char扫描,因此没有正则表达式.

function commafy( num){
  var parts = (''+(num<0?-num:num)).split("."), s=parts[0], L, i=L= s.length, o='';
  while(i--){ o = (i===0?'':((L-i)%3?'':',')) 
                  +s.charAt(i) +o }
  return (num<0?'-':'') + o + (parts[1] ? '.' + parts[1] : ''); 
}

它显示出有前景的表现:http://jsperf.com/number-formatting-with-commas/5

2015.4.26:当num <0时解决问题的次要修复.请参阅https://jsfiddle.net/runsun/p5tqqvs3/


Noah Freitas.. 11

这是一个简单的函数,可以为千位分隔符插入逗号.它使用数组函数而不是RegEx.

/**
 * Format a number as a string with commas separating the thousands.
 * @param num - The number to be formatted (e.g. 10000)
 * @return A string representing the formatted number (e.g. "10,000")
 */
var formatNumber = function(num) {
    var array = num.toString().split('');
    var index = -3;
    while (array.length + index > 0) {
        array.splice(index, 0, ',');
        // Decrement by 4 since we just added another unit to the array.
        index -= 4;
    }
    return array.join('');
};

CodeSandbox链接示例:https://codesandbox.io/s/p38k63w0vq


小智.. 10

使用此代码可处理印度的货币格式。可以更改国家/地区代码以处理其他国家/地区的货币。

let amount =350256.95
var formatter = new Intl.NumberFormat('en-IN', {
  minimumFractionDigits: 2,
});

// Use it.

formatter.format(amount);

输出:

3,50,256.95


Oliver.. 9

您也可以使用Intl.NumberFormat构造函数。这是您的操作方法。

 resultNumber = new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(yourNumber); 


Ronnie Overb.. 7

我在写这篇文章之前写了这篇文章.没有正则表达式,你可以真正理解代码.

$(function(){
  
  function insertCommas(s) {

    // get stuff before the dot
    var d = s.indexOf('.');
    var s2 = d === -1 ? s : s.slice(0, d);

    // insert commas every 3 digits from the right
    for (var i = s2.length - 3; i > 0; i -= 3)
      s2 = s2.slice(0, i) + ',' + s2.slice(i);

    // append fractional part
    if (d !== -1)
      s2 += s.slice(d);

    return s2;

  }
  
  
  $('#theDudeAbides').text( insertCommas('1234567.89012' ) );
  
  
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<div id="theDudeAbides"></div>


小智.. 6

对我来说,最好的答案是像一些成员所说的那样使用toLocaleString.如果您想要包含'$'符号,只需添加语言和类型选项即可.以下是将数字格式化为墨西哥比索的示例

var n = 1234567.22
alert(n.toLocaleString("es-MX",{style:"currency", currency:"MXN"}))

捷径

1234567.22.toLocaleString("es-MX",{style:"currency", currency:"MXN"})


Beder Acosta.. 5

让我试着改善uKolka答案,也许可以帮助别人节省一些时间.

使用Numeral.js.

document.body.textContent = numeral(1234567).format('0,0');
<script src="//cdnjs.cloudflare.com/ajax/libs/numeral.js/1.4.5/numeral.min.js"></script>

只有当浏览器兼容性不是问题时,才应使用Number.prototype.toLocaleString().


Kiry Meas.. 5

var formatNumber = function (number) {
  var splitNum;
  number = Math.abs(number);
  number = number.toFixed(2);
  splitNum = number.split('.');
  splitNum[0] = splitNum[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  return splitNum.join(".");
}

编辑:该功能仅适用于正数。例如:

var number = -123123231232;
formatNumber(number)

输出:“ 123,123,231,232”

但是回答以上toLocaleString()方法的问题只能解决问题。

var number = 123123231232;
    number.toLocaleString()

输出:“ 123,123,231,232”

欢呼!


归档时间:

查看次数:

1053034 次

最近记录:

8 月,2 周 前