# How to print a number with commas as thousands separators in JavaScript

I am trying to print an integer in JavaScript with commas as thousands separators. For example, I want to show the number 1234567 as "1,234,567". How would I go about doing this?

Here is how I am doing it:

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

Is there a simpler or more elegant way to do it? It would be nice if it works with floats also, but that is not necessary. It does not need to be locale-specific to decide between periods and commas.

I used the idea from Kerry's answer, but simplified it since I was just looking for something simple for my specific purpose. Here is what I did:

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

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

function test(x, expect) {
const result = numberWithCommas(x);
const pass = result === expect;
console.log(`\${pass ? "?" : "ERROR ====>"} \${x} => \${result}`);
return pass;
}

let failures = 0;
failures += !test(0,        "0");
failures += !test(100,      "100");
failures += !test(1000,     "1,000");
failures += !test(10000,    "10,000");
failures += !test(100000,   "100,000");
failures += !test(1000000,  "1,000,000");
failures += !test(10000000, "10,000,000");
if (failures) {
console.log(`\${failures} test(s) failed`);
} else {
console.log("All tests passed");
}``````
``````.as-console-wrapper {
max-height: 100% !important;
}``````

The regex uses 2 lookahead assertions:

• a positive one to look for any point in the string that has a multiple of 3 digits in a row after it,
• a negative assertion to make sure that point only has exactly a multiple of 3 digits. The replacement expression puts a comma there.

For example, if you pass it `123456789.01`, the positive assertion will match every spot to the left of the 7 (since `789` is a multiple of 3 digits, `678` is a multiple of 3 digits, `567`, etc.). The negative assertion checks that the multiple of 3 digits does not have any digits after it. `789` has a period after it so it is exactly a multiple of 3 digits, so a comma goes there. `678` is a multiple of 3 digits but it has a `9` after it, so those 3 digits are part of a group of 4, and a comma does not go there. Similarly for `567`. `456789` is 6 digits, which is a multiple of 3, so a comma goes before that. `345678` is a multiple of 3, but it has a `9` after it, so no comma goes there. And so on. The `\B` keeps the regex from putting a comma at the beginning of the string.

@neu-rah mentioned that this function adds commas in undesirable places if there are more than 3 digits after the decimal point. If this is a problem, you can use this function:

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

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

function test(x, expect) {
const result = numberWithCommas(x);
const pass = result === expect;
console.log(`\${pass ? "?" : "ERROR ====>"} \${x} => \${result}`);
return pass;
}

let failures = 0;
failures += !test(0              , "0");
failures += !test(0.123456       , "0.123456");
failures += !test(100            , "100");
failures += !test(100.123456     , "100.123456");
failures += !test(1000           , "1,000");
failures += !test(1000.123456    , "1,000.123456");
failures += !test(10000          , "10,000");
failures += !test(10000.123456   , "10,000.123456");
failures += !test(100000         , "100,000");
failures += !test(100000.123456  , "100,000.123456");
failures += !test(1000000        , "1,000,000");
failures += !test(1000000.123456 , "1,000,000.123456");
failures += !test(10000000       , "10,000,000");
failures += !test(10000000.123456, "10,000,000.123456");
if (failures) {
console.log(`\${failures} test(s) failed`);
} else {
console.log("All tests passed");
}``````
``````.as-console-wrapper {
max-height: 100% !important;
}``````

@t.j.crowder pointed out that now that JavaScript has lookbehind (support info), it can be solved in the regular expression itself:

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

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

function test(x, expect) {
const result = numberWithCommas(x);
const pass = result === expect;
console.log(`\${pass ? "?" : "ERROR ====>"} \${x} => \${result}`);
return pass;
}

let failures = 0;
failures += !test(0,               "0");
failures += !test(0.123456,        "0.123456");
failures += !test(100,             "100");
failures += !test(100.123456,      "100.123456");
failures += !test(1000,            "1,000");
failures += !test(1000.123456,     "1,000.123456");
failures += !test(10000,           "10,000");
failures += !test(10000.123456,    "10,000.123456");
failures += !test(100000,          "100,000");
failures += !test(100000.123456,   "100,000.123456");
failures += !test(1000000,         "1,000,000");
failures += !test(1000000.123456,  "1,000,000.123456");
failures += !test(10000000,        "10,000,000");
failures += !test(10000000.123456, "10,000,000.123456");
if (failures) {
console.log(`\${failures} test(s) failed`);
} else {
console.log("All tests passed");
}``````
``````.as-console-wrapper {
max-height: 100% !important;
}``````

`(?<!\.\d*)` is a negative lookbehind that says the match can't be preceded by a `.` followed by zero or more digits. The negative lookbehind is faster than the `split` and `join` solution (comparison), at least in V8.

I'm surprised nobody mentioned Number.prototype.toLocaleString. It's implemented in JavaScript 1.5 (which was introduced in 1999) so it's basically supported across all major browsers.

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

It also works in Node.js as of v0.12 via inclusion of Intl

Just pay attention that this function returns a string, not a number.

If you want something different, Numeral.js might be interesting.

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

? Mind that javascript has a maximum integer value of 9007199254740991

``````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 not supported):

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

From what I checked (Firefox at least) they are both more or less same regarding performance.

I suggest using phpjs.org 's 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.length > 3) {
s = s.replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
}
if ((s || '').length < prec) {
s = s || '';
s += new Array(prec - s.length + 1).join('0');
}
return s.join(dec);
}
``````

UPDATE 02/13/14

People have been reporting this doesn't work as expected, so I did a JS Fiddle that includes automated tests.

Update 26/11/2017

Here's that fiddle as a Stack Snippet with slightly modified output:

``````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.length > 3) {
s = s.replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
}
if ((s || '').length < prec) {
s = s || '';
s += new Array(prec - s.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;
}``````

This is a variation of @mikez302's answer, but modified to support numbers with decimals (per @neu-rah's feedback that numberWithCommas(12345.6789) -> "12,345.6,789" instead of "12,345.6789"

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

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

Using Regular expression

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

Using 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
``````

Using 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"
``````

DEMO AT HERE

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

Performance

Intl.NumberFormat

Native JS function. Supported by IE11, Edge, latest Safari, Chrome, Firefox, Opera, Safari on iOS and Chrome on Android.

``````var number = 3500;

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

Thanks to everyone for their replies. I have built off of some of the answers to make a more "one-size-fits-all" solution.

The first snippet adds a function that mimics PHP's `number_format()` to the Number prototype. If I am formatting a number, I usually want decimal places so the function takes in the number of decimal places to show. Some countries use commas as the decimal and decimals as the thousands separator so the function allows these separators to be set.

``````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 = parts.replace(/\B(?=(\d{3})+(?!\d))/g, thousands_sep);

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

You would use this as follows:

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

I found that I often needed to get the number back for math operations, but parseFloat converts 5,000 to 5, simply taking the first sequence of integer values. So I created my own float conversion function and added it to the String prototype.

``````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 = parts.replace(re, '');

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

Now you can use both functions as follows:

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

I think this is the shortest regular expression that does it:

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

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

I checked it on a few numbers and it worked.

I am quite impressed by the number of answers this question has got. I like the answer by uKolka:

``````n.toLocaleString()
``````

But unfortunately, in some locales like Spanish, it does not work (IMHO) as expected for numbers below 10,000:

``````Number(1000).toLocaleString('ES-es')
``````

Gives `1000` and not `1.000`.

So I had to use the answer by Elias Zamaria choosing the right thousands separator character:

``````n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, Number(10000).toLocaleString().substring(2, 3))
``````

This one works well as a one-liner for both locales that use `,` or `.` as the thousands separator and starts working from 1,000 in all cases.

``````Number(1000).toString().replace(/\B(?=(\d{3})+(?!\d))/g, Number(10000).toLocaleString().substring(2, 3))
``````

Gives `1.000` with a Spanish locale context.

Should you want to have absolute control over the way a number is formatted, you may also try the following:

``````let number   = 1234.567
let decimals = 2
let decpoint = '.' // Or Number(0.1).toLocaleString().substring(1, 2)
let thousand = ',' // Or Number(10000).toLocaleString().substring(2, 3)

let n = Math.abs(number).toFixed(decimals).split('.')
n = n.split('').reverse().map((c, i, a) =>
i > 0 && i < a.length && i % 3 == 0 ? c + thousand : c
).reverse().join('')
let final = (Math.sign(number) < 0 ? '-' : '') + n.join(decpoint)

console.log(final)
``````

Gives `1,234.57`.

This one does not need a regular expression. It works by adjusting the number to the desired amount of decimals with `toFixed` first, then dividing it around the decimal point `.` if there is one. The left side is then turned into an array of digits which is reversed. Then a thousands separator is added every three digits from the start and the result reversed again. The final result is the union of the two parts. The sign of the input number is removed with `Math.abs` first and then put back if necessary.

It is not a one-liner but not much longer and easily turned into a function. Variables have been added for clarity, but those may be substituted by their desired values if known in advance. You may use the expressions that use `toLocaleString` as a way to find out the right characters for the decimal point and the thousands separator for the current locale (bear in mind that those require a more modern Javascript.)

`Number.prototype.toLocaleString()` would have been awesome if it was provided natively by all browsers (Safari).

I checked all other answers but noone seemed to polyfill it. Here is a poc towards that, which is actually a combination of first two answers; if `toLocaleString` works it uses it, if it doesn't it uses a custom function.

``````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 = parts.replace(/\B(?=(\d{3})+(?!\d))/g, sep);
// put them back together
value = parts ? parts.join('.') : parts;
} else {
value = value.toLocaleString();
}
return value;
};

The thousands separator can be inserted in an international-friendly manner using the browser's `Intl` object:

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

See MDN's article on NumberFormat for more, you can specify locale behavior or default to the user's. This is a little more foolproof because it respects local differences; many countries use periods to separate digits while a comma denotes the decimals.

Intl.NumberFormat isn't available in all browsers yet, but it works in latest Chrome, Opera, & IE. Firefox's next release should support it. Webkit doesn't seem to have a timeline for implementation.

You can either use this procedure to format your currency needing.

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

if you are dealing with currency values and formatting a lot then it might be worth to add tiny accounting.js which handles lot of edge cases and localization:

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

The following code uses char scan, so there's no regex.

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

It shows promising performance: http://jsperf.com/number-formatting-with-commas/5

2015.4.26: Minor fix to resolve issue when num<0. See https://jsfiddle.net/runsun/p5tqqvs3/

Here's a simple function that inserts commas for thousand separators. It uses array functions rather than a 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('');
};
``````

Use This code to handle currency format for india. Country code can be changed to handle other country currency.

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

// Use it.

formatter.format(amount);
``````

output:

``````3,50,256.95
``````

You can also use the Intl.NumberFormat constructor. Here is how you can do it.

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

I Wrote this one before stumbling on this post. No regex and you can actually understand the code.

``````\$(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>``````

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

EDIT: The function only work with positive number. for exmaple:

``````var number = -123123231232;
formatNumber(number)
``````

Output: "123,123,231,232"

But to answer the question above `toLocaleString()` method just solves the problem.

``````var number = 123123231232;
number.toLocaleString()
``````

Output: "123,123,231,232"

Cheer!

My answer is the only answer that completely replaces jQuery with a much more sensible alternative:

``````function \$(dollarAmount)
{
const locale = 'en-US';
const options = { style: 'currency', currency: 'USD' };
return Intl.NumberFormat(locale, options).format(dollarAmount);
}
``````

This solution not only adds commas, but it also rounds to the nearest penny in the event that you input an amount like `\$(1000.9999)` you'll get \$1,001.00. Additionally, the value you input can safely be a number or a string; it doesn't matter.

If you're dealing with money, but don't want a leading dollar sign shown on the amount, you can also add this function, which uses the previous function but removes the `\$`:

``````function no\$(dollarAmount)
{
return \$(dollarAmount).replace('\$','');
}
``````

If you're not dealing with money, and have varying decimal formatting requirements, here's a more versatile function:

``````function addCommas(number, minDecimalPlaces = 0, maxDecimalPlaces = Math.max(3,minDecimalPlaces))
{
const options = {};
options.maximumFractionDigits = maxDecimalPlaces;
options.minimumFractionDigits = minDecimalPlaces;
return Intl.NumberFormat('en-US',options).format(number);
}
``````

Oh, and by the way, the fact that this code does not work in some old version of Internet Explorer is completely intentional. I try to break IE anytime that I can catch it not supporting modern standards.

Please remember that excessive praise, in the comment section, is considered off-topic. Instead, just shower me with up-votes.

For me, the best answer is using toLocaleString like some members said. If you want to include the '\$' symbol just add languaje and type options. Here is and example to format a number to Mexican Pesos

``````var n = 1234567.22

shortcut

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

Let me try to improve uKolka's answer and maybe help others save some time.

Use 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>``

You should go with Number.prototype.toLocaleString() only if its browser compatibilty is not an issue.

An alternative way, supporting decimals, different separators and negatives.

``````var number_format = function(number, decimal_pos, decimal_sep, thousand_sep) {
var ts      = ( thousand_sep == null ? ',' : thousand_sep )
, ds    = ( decimal_sep  == null ? '.' : decimal_sep )
, dp    = ( decimal_pos  == null ? 2   : decimal_pos )

, n     = Math.floor(Math.abs(number)).toString()

, i     = n.length % 3
, f     = ((number < 0) ? '-' : '') + n.substr(0, i)
;

for(;i<n.length;i+=3) {
if(i!=0) f+=ts;
f+=n.substr(i,3);
}

if(dp > 0)
f += ds + parseFloat(number).toFixed(dp).split('.')

return f;
}
``````

Some corrections by @Jignesh Sanghani, don't forget to upvote his comment.

I think this function will take care of all the issues related to this problem.

``````function commaFormat(inputString) {
inputString = inputString.toString();
var decimalPart = "";
if (inputString.indexOf('.') != -1) {
inputString = inputString.split(".");
decimalPart = "." + inputString;
inputString = inputString;

}
var outputString = "";
var count = 0;
for (var i = inputString.length - 1; i >= 0 && inputString.charAt(i) != '-'; i--) {
//alert("inside for" + inputString.charAt(i) + "and count=" + count + " and outputString=" + outputString);
if (count == 3) {
outputString += ",";
count = 0;
}
outputString += inputString.charAt(i);
count++;
}
if (inputString.charAt(0) == '-') {
outputString += "-";
}
return outputString.split("").reverse().join("") + decimalPart;
}
``````

All of solutions mentioned above are wonderful, however, RegExp might be awfully bad thing to use in a situation like that.

So, yes, you might use some of the options proposed or even write something primitive yet useful like:

``````const strToNum = str => {

//Find 1-3 digits followed by exactly 3 digits & a comma or end of string
let regx = /(\d{1,3})(\d{3}(?:,|\$))/;
let currStr;

do {
currStr = (currStr || str.split(`.`))
.replace( regx, `\$1,\$2`)
} while (currStr.match(regx)) //Stop when there's no match & null's returned

return ( str.split(`.`) ) ?
currStr.concat(`.`, str.split(`.`)) :
currStr;

};

strToNum(`123`) // => 123
strToNum(`123456`) // => 123,456
strToNum(`-1234567.0987`) // => -1,234,567.0987
``````

The regexp that's used here is fairly simple and the loop will go precisely the number of times it takes to get the job done.

And you might optimize it far better, "DRYify" code & so on.

Yet,

``````(-1234567.0987).toLocaleString();
``````

(in most situations) would be a far better choice.

The point is not in the speed of execution or in cross-browser compatibility.

In situations when you'd like to show the resulting number to user, .toLocaleString() method gives you superpower to speak the same language with the user of your website or app (whatever her/his language is).

This method according to ECMAScript documentation was introduced in 1999, and I believe that the reason for that was the hope that the Internet at some point will connect people all around the world, so, some "internalization" tools were needed.

Today the Internet does connect all of us, so, it is important to remember that the world is a way more complex that we might imagine & that (/almost) all of us are here, in the Internet.

Obviously, considering the diversity of people, it is impossible to guarantee perfect UX for everybody because we speak different languages, value different things, etc. And exactly because of this, it is even more important to try to localize things as much as it's possible.

So, considering that there're some particular standards for representation of date, time, numbers, etc. & that we have a tool to display those things in the format preferred by the final user, isn't that rare and almost irresponsible not to use that tool (especially in situations when we want to display this data to the user)?

For me, using RegExp instead of .toLocaleString() in situation like that sounds a little bit like creating a clock app with JavaScript & hard-coding it in such a way so it'll display Prague time only (which would be quite useless for people who don't live in Prague) even though the default behaviour of

``````new Date();
``````

is to return the data according to final user's clock.

# My “true” regular-expressions-only solution for those love one-liners

You see those enthusiastic players above? Maybe you can golf out of it. Here’s my stroke.

``````n => `\${n}`.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, "?").replace(/(?<=\.(\d{3})+)\B/g, "?")
``````

Uses a `?`THIN SPACE (U+2009) for a thousands separator, as the International System of Units said to do in the eighth edition(2006) of their publication “SI Brochure: The International System of Units (SI) (See §5.3.4.). The ninth edition(2019) suggests to use a space for it (See §5.4.4.). You can use whatever you want, including a comma.

## See.

``````const integer_part_only = n => `\${n}`.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, " I ");
const fractional_part_only = n => `\${n}`.replace(/(?<=\.(\d{3})+)\B/g, " F ");
const both = n => fractional_part_only(integer_part_only(n));

function demo(number) { // I’m using Chrome 74.
console.log(`\${number}
? "\${integer_part_only(number)}" (integer part only)
? "\${fractional_part_only(number)}" (fractional part only)
? "\${both(number)}" (both)
`);
}
demo(Math.random() * 10e5);
demo(123456789.01234567);
demo(123456789);
demo(0.0123456789);``````

## How does it work?

### For an integer part

``````.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, " I ")
``````
• `.replace(……, " I ")` Put “ I ”
• `/……/g` at each of
• `\B` the in-between of two adjacent digits
• `(?=……)`POSITIVE LOOKAHEAD whose right part is
• `(\d{3})+` one or more three-digit chunks
• `\b` followed by a non-digit, such as, a period, the ending of the string, et cetera,
• `(?<!……)`NEGATIVE LOOKBEHIND excluding ones whose left part
• `\.\d+` is a dot followed by digits (“has a decimal separator”).

### For a decimal part

``````.replace(/(?<=\.(\d{3})+)\B/g, " F ")
``````
• `.replace(……, " F ")` Put “ F ”
• `/……/g` at each of
• `\B` the in-between of two adjacent digits
• `(?<=……)`POSITIVE LOOKBEHIND whose left part is
• `\.` a decimal separator
• `(\d{3})+` followed by one or more three-digit chunks.

## Character classes and boundaries

### `\d`

Matches any digit (Arabic numeral). Equivalent to `[0-9]`.

For example,

• `/\d/` or `/[0-9]/` matches `2` in `B2 is the suite number`.

### `\b`

Matches a word boundary. This is the position where a word character is not followed or preceded by another word-character, such as between a letter and a space. Note that a matched word boundary is not included in the match. In other words, the length of a matched word boundary is zero.

Examples:

• `/\bm/` matches the `m` in `moon` ;
• `/oo\b/` does not match the `oo` in `moon`, because `oo` is followed by `n` which is a word character;
• `/oon\b/` matches the `oon` in `moon`, because `oon` is the end of the string, thus not followed by a word character;
• `/\w\b\w/` will never match anything, because a word character can never be followed by both a non-word and a word character.

### `\B`

Matches a non-word boundary. This is a position where the previous and next character are of the same type: either both must be words, or both must be non-words. Such as between two letters or between two spaces. The beginning and end of a string are considered non-words. Same as the matched word boundary, the matched non-word boundary is also not included in the match.

For example,

• `/\Bon/` matches `on` in `at noon`;
• `/ye\B/` matches `ye` in `possibly yesterday`.

## Browser compatibility

I added tofixed to Aki143S's solution. This solution uses dots for thousands separators and comma for the precision.

``````function formatNumber( num, fixed ) {
var decimalPart;

var array = Math.floor(num).toString().split('');
var index = -3;
while ( array.length + index > 0 ) {
array.splice( index, 0, '.' );
index -= 4;
}

if(fixed > 0){
decimalPart = num.toFixed(fixed).split(".");
return array.join('') + "," + decimalPart;
}
return array.join('');
};
``````

Examples;

``````formatNumber(17347, 0)  = 17.347
formatNumber(17347, 3)  = 17.347,000
formatNumber(1234563.4545, 3)  = 1.234.563,454
``````

``````function format(num, fix) {
var p = num.toFixed(fix).split(".");
return p.split("").reduceRight(function(acc, num, i, orig) {
if ("-" === num && 0 === i) {
return num + acc;
}
var pos = orig.length - i - 1
return  num + (pos && !(pos % 3) ? "," : "") + acc;
}, "") + (p ? "." + p : "");
}
``````

Some examples:

``````format(77.03453, 2); // "77.03"
format(78436589374); // "78,436,589,374"
format(784, 4);      // "784.0000"
format(-123456);     // "-123,456"
``````

For anyone who likes 1-liners and a single regex, but doesn't want to use split(), here is an enhanced version of the regex from other answers that handles (ignores) decimal places:

``````    var formatted = (x+'').replace(/(\..*)\$|(\d)(?=(\d{3})+(?!\d))/g, (digit, fract) => fract || digit + ',');
``````

The regex first matches a substring starting with a literal "." and replaces it with itself ("fract"), and then matches any digit followed by multiples of 3 digits and puts "," after it.

For example, x = 12345678.12345678 will give formatted = '12,345,678.12345678'.

# Performance

Today (2020.07.10) I perform tests for chosen solutions on Chrome 83.0, Safari 13.1 and Firefox 77.0. This results can be useful for massive number formatting.

### Conclusions

• Solution H based on `regexp-while` is fastest
• Solutions M based on `reduce` and N based on `while` are quite fast
• Solutions A-D based on `regexp` are short quite fast
• Solutions J,K,L based on `Intl` and toLocaleString are slow ### Details

I perform tests for solutions A B C D E F G H I J K L M(my) N O P Below snippet presents them (solution O gives wrong results for minus numbers). You can run it HERE

``````// https://jsbench.me/zqkcggc1hs/1

// https://stackoverflow.com/a/29026196/860099
function A(x) {
return (''+x).replace(/\B(?=(\d{3})+\b)/g, ",")
}

// https://stackoverflow.com/a/36921381/860099
function B(x) {
return (x+'').replace(/\B(?=(\d\d\d)+\b)/g, ",");
}

// https://stackoverflow.com/a/14297552/860099
function C(x) {
return (x+'').replace(/\B(?=(\d{3})+(?=\$))/g, ",")
}

// https://stackoverflow.com/a/2901298/860099
function D(x) {
return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

// https://stackoverflow.com/a/25377176/860099
function E(x) {
return x.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, "\$1,")
}

// https://stackoverflow.com/a/58906636/860099
function F(x) {
return (x+'').replace(/(\..*)\$|(\d)(?=(\d{3})+(?!\d))/g, (digit, fract) => fract || digit + ',');
}

// https://stackoverflow.com/a/61132076/860099
function G(x) {
let numParts = x.toString().split('.');
numParts = numParts.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
return numParts.join('.');
}

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

// https://stackoverflow.com/a/17663871/860099
function I(x) {
return x.toLocaleString()
}

// https://stackoverflow.com/a/51322015/860099
function J(x) {
return x.toLocaleString('en-GB')
}

// https://stackoverflow.com/a/23305614/860099
function K(x) {
return Intl.NumberFormat().format(x);
}

// https://stackoverflow.com/a/32154217/860099
function L(x) {
var nf = new Intl.NumberFormat();
return nf.format(x);
}

// my
function M(x) {
return [...''+x].reduceRight((a,c,i,r)=> a= c+((r.length-i-1)%3||c=='-'?'':',') + a);
}

// https://stackoverflow.com/a/17980867/860099
function N(x) {
var parts = (''+(x<0?-x:x)).split("."), s=parts, L, i=L= s.length, o='';
while(i--){ o = (i===0?'':((L-i)%3?'':','))
+s.charAt(i) +o }
return (x<0?'-':'') + o + (parts ? '.' + parts : '');
}

// https://stackoverflow.com/a/10418247/860099
function O(x) {
var array = x.toString().split('');
var index = -3;
while (array.length + index > 0) {
array.splice(index, 0, ',');
index -= 4;
}
return array.join('');
}

// https://stackoverflow.com/a/21004504/860099
function P(x,fix=0) {
var p = x.toFixed(fix).split(".");
return p.split("").reduceRight(function(acc, num, i, orig) {
if ("-" === num && 0 === i) {
return num + acc;
}
var pos = orig.length - i - 1
return  num + (pos && !(pos % 3) ? "," : "") + acc;
}, "") + (p ? "." + p : "");
}

// ---------
// TEST
// ---------

[A,B,C,D,E,F,G,H,I,K,L,M,N,O,P].forEach( f=> console.log(`\${f.name}: \${[
123456, 1234567, -1234567, -123456, -12345
].map(x=>f(x)).join(' | ')}`) );``````
``This snippet only presents used code``

Example results for Chrome codePen

``````function seprator(input) {
let nums = input.value.replace(/,/g, '');
if(!nums || nums.endsWith('.'))  return;
input.value = parseFloat(nums).toLocaleString();

}``````
``<input type="text" id="inputSep" oninput="seprator(this)" placeholder="123,456,789"/>``