JavaScript中的数字格式类似于C#

是否有一种简单的方法可以在JavaScript中格式化数字，类似于C#（或VB.NET）中通过

ToString（“格式提供程序”）

或

String.format（）

？

通常情况下的格式化方法

jQuery中的

• （一个不错的数字格式化程序和输入助手，支持jQuery 1.5+）
• （Java和的客户端实现）

---

首先，在JS中将整数转换为字符串非常简单：

// Start off with a number
var number = 42;
// Convert into a string by appending an empty (or whatever you like as a string) to it
var string = 42+'';
// No extra conversion is needed, even though you could actually do
var alsoString = number.toString();

如果将数字作为字符串并希望将其转换为整数，则必须使用

parseInt（string）

表示整数，使用

parseFloat（string）

表示浮点数。然后，这两个函数都返回所需的整数/浮点。例如：

// Start off with a float as a string
var stringFloat = '3.14';
// And an int as a string
var stringInt = '42';

// typeof stringInt  would give you 'string'

// Get the real float from the string
var realFloat = parseFloat(someFloat);
// Same for the int
var realInt = parseInt(stringInt);

// but typeof realInt  will now give you 'number'

---

从你的问题来看，我还不清楚你到底想在etc后面加什么。

这里有一个简单的JS函数，可以将逗号添加到字符串格式的整数中。它将处理整数或十进制数。您可以传递数字或字符串。它显然返回一个字符串

function addCommas(str) {
    var parts = (str + "").split("."),
        main = parts[0],
        len = main.length,
        output = "",
        first = main.charAt(0),
        i;

    if (first === '-') {
        main = main.slice(1);
        len = main.length;    
    } else {
        first = "";
    }
    i = len - 1;
    while(i >= 0) {
        output = main.charAt(i) + output;
        if ((len - i) % 3 === 0 && i > 0) {
            output = "," + output;
        }
        --i;
    }
    // put sign back
    output = first + output;
    // put decimal part back
    if (parts.length > 1) {
        output += "." + parts[1];
    }
    return output;
}

下面是一组测试用例：

您可以看到它在前面的JSFIDLE中使用。通过简单的谷歌搜索“javascript添加逗号”，您也可以找到处理十进制数的函数

将数字转换为字符串有多种方法。最简单的方法是将其添加到字符串中：

var myNumber = 3;
var myStr = "" + myNumber;   // "3"

在JSFIDLE的上下文中，您可以通过更改以下行在计数器中输入逗号：

jTarget.text(current);

为此：

jTarget.text(addCommas(current));

---

您可以看到它在这里工作：

是的，有一种方法可以在javascript中正确设置数字格式，例如：

var val=2489.8237

val.toFixed(3) //returns 2489.824 (round up)
val.toFixed(2) //returns 2489.82
val.toFixed(7) //returns 2489.8237000 (padding)

var flt = '5.99';
var nt = '6';

var rflt = parseFloat(flt);
var rnt = parseInt(nt);

使用variablename.toFixed

还有另一个函数

toPrecision（）

。 有关更多详细信息，您还可以访问

---

使用JQuery

$(document).ready(function()
 {
    //Only number and one dot
    function onlyDecimal(element, decimals)
    {
        $(element).keypress(function(event)
        {
            num = $(this).val() ;
            num = isNaN(num) || num === '' || num === null ? 0.00 : num ;
            if ((event.which != 46 || $(this).val().indexOf('.') != -1) && (event.which < 48 || event.which > 57))
            {
                event.preventDefault();

            }
            if($(this).val() == parseFloat(num).toFixed(decimals))
            {
                event.preventDefault();
            }
        });
    }

     onlyDecimal("#TextBox1", 3) ;



});

$（文档）.ready（函数（）
{
//只有数字和一个点
仅函数小数（元素，小数）
{
$（元素）。按键（功能（事件）
{
num=$（this.val（）；
num=isNaN（num）| | num==''| | num===null？0.00:num；
if（（event.which！=46 | | |$（this.val（）.indexOf（'.'）！=1）和&（event.which<48 | | event.which>57））
{
event.preventDefault（）；
}
if（$（this.val（）==parseFloat（num）.toFixed（小数））
{
event.preventDefault（）；
}
});
}
仅限CIMAL（“文本框1”，3）；
});

---

如果您不想使用jQuery，请查看以下示例：

var val=2489.8237

val.toFixed(3) //returns 2489.824 (round up)
val.toFixed(2) //returns 2489.82
val.toFixed(7) //returns 2489.8237000 (padding)

var flt = '5.99';
var nt = '6';

var rflt = parseFloat(flt);
var rnt = parseInt(nt);

:

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

更新

正如TomášZato所说，这里有一条线解决方案：

(666.0).toLocaleString()
numObj.toLocaleString([locales [, options]])

ECMA-262 5.1版中描述的：

---

并且将在未来版本的浏览器中工作…

这里是另一个版本：

$.fn.digits = function () {
    return this.each(function () {
        var value = $(this).text();
        var decimal = "";
        if (value) {
            var pos = value.indexOf(".");
            if (pos >= 0) {
                decimal = value.substring(pos);
                value = value.substring(0, pos);
            }
            if (value) {
                value = value.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
                if (!String.isNullOrEmpty(decimal)) value = (value + decimal);
                $(this).text(value);
            }
        }
        else {
            value = $(this).val()
            if (value) {
                var pos = value.indexOf(".");
                if (pos >= 0) {
                    decimal = value.substring(pos);
                    value = value.substring(0, pos);
                }
                if (value) {
                    value = value.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
                    if (!String.isNullOrEmpty(decimal)) value = (value + decimal);
                    $(this).val(value);
                }
            }
        }
    })
};

---

要获得逗号后有2个数字的十进制数，可以使用：

function nformat(a) {
   var b = parseInt(parseFloat(a)*100)/100;
   return b.toFixed(2);
}

---

这里有一些解决方案，都通过了测试套件，包括测试套件和基准测试，如果您想复制并粘贴到测试中，请尝试

方法0（RegExp） 基于，但如果没有小数点则修复

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 方法3（循环） 例子 测试套件 基准

功能基准（f）{
var start=new Date（）.getTime（）；
f（）；
返回新日期（）.getTime（）-start；
}
函数基准\u格式（f）{
控制台日志（f）；
时间=基准（函数（）{
对于（变量i=0；i<100000；i++）{
f、 电话（123456789,0）；
f、 电话(123456789,2);；
}
});
console.log（time.format（0）+“ms”）；
}
异步=[]；
函数next（）{
setTimeout（函数（）{
f=async.shift（）；
f&&f（）；
next（）；
}, 10);
}
console.log（'==========Benchmark=========='）；
push（函数（）{benchmark_格式（Number.prototype.format）；}）；
push（函数（）{benchmark_格式（Number.prototype.format1）；}）；
push（函数（）{benchmark_格式（Number.prototype.format2）；}）；
push（函数（）{benchmark_格式（Number.prototype.format3）；}）；
next（）；

我编写了一个简单的函数（还不需要另一个jQuery插件！！），它可以将一个数字转换为十进制分隔字符串或空字符串（如果该数字不是以数字开头）：

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

格式（578999）导致
578999

格式（10）导致
10

如果希望使用小数点而不是逗号，只需将代码中的逗号替换为小数点即可

其中一条评论正确地指出，这只适用于整数，通过一些小的调整，您也可以使其适用于浮点：

function format(x) {
    if(isNaN(x))return "";

    n= x.toString().split('.');
    return n[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",")+(n.length>1?"."+n[1]:"");
}

我做了一个简单的函数，也许有人可以使用它

function secsToTime(secs){
  function format(number){
    if(number===0){
      return '00';
    }else {
      if (number < 10) {
          return '0' + number
      } else{
          return ''+number;
      }
    }
  }

  var minutes = Math.floor(secs/60)%60;
  var hours = Math.floor(secs/(60*60))%24;
  var days = Math.floor(secs/(60*60*24));
  var seconds = Math.floor(secs)%60;

  return (days>0? days+"d " : "")+format(hours)+':'+format(minutes)+':'+format(seconds);
}

函数秒时间（秒）{
函数格式（数字）{
如果（数字==0）{
返回'00'；
}否则{
如果（数字<10）{
返回“0”+数字
}否则{
返回“”+数字；
}
}
}
var分钟=数学地板（秒/60）%60；
var小时=数学楼层（秒/（60*60））%24；
变量天数=数学下限（秒/（60*60*24））；
var秒=数学地板（秒）%60；
返回（天>0？天+“d”：“”）+格式（小时）+'：'+格式（分钟）+'：'+格式（秒）；
}

这可以产生以下输出：


5d 02:53:39
4d 22:15:16
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 padding
    assertEqual('1.00', format_function.call(1, 2))
    assertEqual('-1.00', format_function.call(-1, 2))
    // decimal rounding
    assertEqual('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 separator
    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))
    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 decimal
    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))
    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');
}

async = [];
function next() {
    setTimeout(function () {
        f = async.shift();
        f && f();
        next();
    }, 10);
}

console.log('======== Benchmark ========');
async.push(function () { benchmark_format(Number.prototype.format); });
async.push(function () { benchmark_format(Number.prototype.format1); });
async.push(function () { benchmark_format(Number.prototype.format2); });
async.push(function () { benchmark_format(Number.prototype.format3); });
next();

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

function format(x) {
    if(isNaN(x))return "";

    n= x.toString().split('.');
    return n[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",")+(n.length>1?"."+n[1]:"");
}

function secsToTime(secs){
  function format(number){
    if(number===0){
      return '00';
    }else {
      if (number < 10) {
          return '0' + number
      } else{
          return ''+number;
      }
    }
  }

  var minutes = Math.floor(secs/60)%60;
  var hours = Math.floor(secs/(60*60))%24;
  var days = Math.floor(secs/(60*60*24));
  var seconds = Math.floor(secs)%60;

  return (days>0? days+"d " : "")+format(hours)+':'+format(minutes)+':'+format(seconds);
}

function numberFormat( number ){

    var digitCount = (number+"").length;
    var formatedNumber = number+"";
    var ind = digitCount%3 || 3;
    var temparr = formatedNumber.split('');

    if( digitCount > 3 && digitCount <= 6 ){

        temparr.splice(ind,0,',');
        formatedNumber = temparr.join('');

    }else if (digitCount >= 7 && digitCount <= 15) {
        var temparr2 = temparr.slice(0, ind);
        temparr2.push(',');
        temparr2.push(temparr[ind]);
        temparr2.push(temparr[ind + 1]);
        // temparr2.push( temparr[ind + 2] ); 
        if (digitCount >= 7 && digitCount <= 9) {
            temparr2.push(" million");
        } else if (digitCount >= 10 && digitCount <= 12) {
            temparr2.push(" billion");
        } else if (digitCount >= 13 && digitCount <= 15) {
            temparr2.push(" trillion");

        }
        formatedNumber = temparr2.join('');
    }
    return formatedNumber;
}

function format(number, decimals = 2, decimalSeparator = '.', thousandsSeparator = ',') {
    const roundedNumber = number.toFixed(decimals);
    let integerPart = '', fractionalPart = '';
    if (decimals == 0) {
        integerPart = roundedNumber;
        decimalSeparator = '';
    } else {
        let numberParts = roundedNumber.split('.');
        integerPart = numberParts[0];
        fractionalPart = numberParts[1];
    }
    integerPart = integerPart.replace(/(\d)(?=(\d{3})+(?!\d))/g, `$1${thousandsSeparator}`);
    return `${integerPart}${decimalSeparator}${fractionalPart}`;
}

let min = 1556454.0001;
let max = 15556982.9999;
console.time('number format');
for (let i = 0; i < 15000; i++) {
    let randomNumber = Math.random() * (max - min) + min;

    let formated = format(randomNumber, 4, ',', '.'); // formated number

    console.debug('number: ', randomNumber, 'formated: ', formated);
}
console.timeEnd('number format');