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

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.57
console.log((4216635.57).formatCurrency('.', ','))
$4.216.635,57
console.log((4216635.57).formatCurrency('.', ',', "\u20AC"))
€4.216.635,57

哦，它也适用于负数：

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

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

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

此答案符合以下标准：

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

此代码基于其他答案中的概念。如果这是一个问题的话，它的执行速度应该是最好的。

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

已经有好的答案了。这里有一个简单的乐趣尝试：

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

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

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

变量编号=12346.789；//德语使用逗号作为小数分隔符，句点表示千console.log（新Intl.NumberFormat（'de-de'）.format（数字））；//→123.456,789//大多数阿拉伯语国家的阿拉伯语使用真正的阿拉伯数字console.log（新Intl.NumberFormat（'ar-EG'）.format（数字））；//→١٢٣٤٥٦٫٧٨٩//印度使用数千/十万/千个分隔符console.log（新Intl.NumberFormat（'en-IN'）.format（数字））；

tggagne是正确的。由于浮动舍入，我下面的解决方案不好。toLocaleString函数缺少一些浏览器支持。出于存档目的，我将留下以下评论，说明不该做什么。：）

Date.product.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 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 -> MFXO
        var 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€”的字符串）

除了灵活性之外，我还需要一个处理表的快速解决方案。这意味着，在处理数千个单元格时，格式字符串的处理不能重复一次。我不接受类似“format（value，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包含正则表达式；

第三，类似“format（value，fmt）”的调用是不可接受的，因为：

虽然可以用不同的掩码格式化不同的对象集合（例如，列的单元格），但我不想在处理时处理格式化字符串。此时，我只想使用格式，如

for（单元格中的var单元格）｛do_something（cell.col.formatter(cell.value））；}

什么格式-可能是在.ini文件中，在XML中为每一列或其他地方定义的。。。，但是分析和设置格式或处理国际化完全是在另一个地方进行的，在那里我想将格式化程序分配给集合，而不考虑性能问题：

col.formatter=格式_字符串（_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专家的一个想法和起点。

该代码包含了许多StackOverflow帖子中修改过的想法；很抱歉，我不能引用所有这些，但感谢所有的专家。