还有一个。。（对于问题所问的int）

function insertCommas(str)
{
    var a = str.split("");
    a.reverse();

    var t, i = 0, arr = Array();

    while (t = a.shift())
    {
       if (((i++ % 3) == 0) && arr.length > 0)
           arr.unshift(",");
       arr.unshift(t);
    }

    return arr.join("");
}

已经有很多好答案了。这里还有一个，只是为了好玩：

function format(num, fix) {
    var p = num.toFixed(fix).split(".");
    return p[0].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[1] ? "." + p[1] : "");
}

一些示例：

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

感谢大家的回复。我总结了一些答案，以制定一个更“一刀切”的解决方案。

第一段代码向number原型添加了一个模仿PHP的number_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将5000转换为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

对于任何喜欢1行和单个正则表达式，但不想使用split（）的人，这里有一个来自其他答案的正则表达式的增强版本，它处理（忽略）小数点：

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

正则表达式首先匹配以文字“.”开头的子字符串，并将其替换为自身（“fract”），然后匹配任何数字，后跟3位数的倍数，并将“，”放在其后。

例如，x=12345678.12345678将给出formated=“12345678.12345 678”。

在这里没有找到一个现代和全面的解决方案之后，我编写了一个箭头函数（没有正则表达式）来解决格式化问题，它允许调用者为欧洲和世界其他地区提供小数位数以及句点和千位分隔符。

示例：数字格式化程序（1234567890.123456）=>1234567890数字格式化程序（1234567890.123456，4）=>1234567890.1235numberFormatter（1234567890.123456，4，'.'，'，'）=>1.234.567.8901235欧洲

以下是用ES6（现代语法）编写的函数：

const numberFormatter = (number, fractionDigits = 0, thousandSeperator = ',', fractionSeperator = '.') => {
    if (number!==0 && !number || !Number.isFinite(number)) return number
    const frDigits = Number.isFinite(fractionDigits)? Math.min(Math.max(fractionDigits, 0), 7) : 0
    const num = number.toFixed(frDigits).toString()

    const parts = num.split('.')
    let digits = parts[0].split('').reverse()
    let sign = ''
    if (num < 0) {sign = digits.pop()}
    let final = []
    let pos = 0

    while (digits.length > 1) {
        final.push(digits.shift())
        pos++
        if (pos % 3 === 0) {final.push(thousandSeperator)}
    }
    final.push(digits.shift())
    return `${sign}${final.reverse().join('')}${frDigits > 0 ? fractionSeperator : ''}${frDigits > 0 && parts[1] ? parts[1] : ''}`
}

它已被测试为阴性、不良输入和NaN病例。如果输入是NaN，则只需返回它。

我对这个问题的答案数量印象深刻。我喜欢uKolka的回答：

n.toLocaleString()

但不幸的是，在西班牙语等一些地区，它并不能像预期的那样工作（IMHO）：

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

给出1000而不是1.000。

请参阅所有浏览器中不能处理小于10000的数字的LocaleString，了解原因。

因此，我不得不使用Elias Zamaria选择正确的千位分隔符的答案：

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

对于使用或的两个语言环境，这一行程序都可以很好地作为一行程序使用。在所有情况下，从1000开始工作。

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

给出1.000的西班牙语区域设置上下文。

如果您想对数字的格式进行绝对控制，也可以尝试以下操作：

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[0] = n[0].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)

给出1234.57。

这个不需要正则表达式。它的工作原理是先用toFixed将数字调整到所需的小数位数，然后将其除以小数点。如果有的话。然后将左侧转换为一个数字数组，该数组被反转。然后，从开头开始每三位数字添加一个千位分隔符，结果再次反转。最终的结果是两部分的结合。首先用Math.abs去掉输入数字的符号，必要时再放回去。

它不是一个线性函数，但长度不长，很容易转化为函数。为了清楚起见，添加了变量，但如果事先知道，可以用它们的期望值替换这些变量。您可以使用使用toLocaleString的表达式来查找当前区域设置的小数点和千位分隔符的正确字符（请记住，这些字符需要更现代的Javascript）