ES2020在Intl中增加了对此的支持。使用如下表示法:

let formatter = Intl。NumberFormat('en'，{符号:'紧凑'}); //示例1 让million = formatter.format(1e6); //示例2 Let billion = formatter.format(1e9); / /打印 console.log(million == '1M'， billion == '1B');

注意如上所示，第二个示例生成1B而不是1G。 NumberFormat规格:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat https://tc39.es/ecma402#numberformat-objects

注意，目前并不是所有的浏览器都支持ES2020，所以你可能需要这个 Polyfill: https://formatjs.io/docs/polyfills/intl-numberformat

进一步改进@Yash的回答，支持负数:

function nFormatter(num) {
    isNegative = false
    if (num < 0) {
        isNegative = true
    }
    num = Math.abs(num)
    if (num >= 1000000000) {
        formattedNumber = (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'G';
    } else if (num >= 1000000) {
        formattedNumber =  (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
    } else  if (num >= 1000) {
        formattedNumber =  (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
    } else {
        formattedNumber = num;
    }   
    if(isNegative) { formattedNumber = '-' + formattedNumber }
    return formattedNumber;
}

nFormatter(-120000)
"-120K"
nFormatter(120000)
"120K"

如果你喜欢，就把功劳归于韦伦·弗林

这比他处理负数和“。0”的情况。

循环和“如果”情况越少，IMO就越好。

function abbreviateNumber(number) {
    const SI_POSTFIXES = ["", "k", "M", "G", "T", "P", "E"];
    const sign = number < 0 ? '-1' : '';
    const absNumber = Math.abs(number);
    const tier = Math.log10(absNumber) / 3 | 0;
    // if zero, we don't need a prefix
    if(tier == 0) return `${absNumber}`;
    // get postfix and determine scale
    const postfix = SI_POSTFIXES[tier];
    const scale = Math.pow(10, tier * 3);
    // scale the number
    const scaled = absNumber / scale;
    const floored = Math.floor(scaled * 10) / 10;
    // format number and add postfix as suffix
    let str = floored.toFixed(1);
    // remove '.0' case
    str = (/\.0$/.test(str)) ? str.substr(0, str.length - 2) : str;
    return `${sign}${str}${postfix}`;
}

jsFiddle测试用例-> https://jsfiddle.net/qhbrz04o/9/

不满足任何张贴的解决方案，所以这是我的版本:

Supports positive and negative numbers Supports negative exponents Rounds up to next exponent if possible Performs bounds checking (doesn't error out for very large/small numbers) Strips off trailing zeros/spaces Supports a precision parameter function abbreviateNumber(number,digits=2) { var expK = Math.floor(Math.log10(Math.abs(number)) / 3); var scaled = number / Math.pow(1000, expK); if(Math.abs(scaled.toFixed(digits))>=1000) { // Check for rounding to next exponent scaled /= 1000; expK += 1; } var SI_SYMBOLS = "apμm kMGTPE"; var BASE0_OFFSET = SI_SYMBOLS.indexOf(' '); if (expK + BASE0_OFFSET>=SI_SYMBOLS.length) { // Bound check expK = SI_SYMBOLS.length-1 - BASE0_OFFSET; scaled = number / Math.pow(1000, expK); } else if (expK + BASE0_OFFSET < 0) return 0; // Too small return scaled.toFixed(digits).replace(/(\.|(\..*?))0+$/,'$2') + SI_SYMBOLS[expK+BASE0_OFFSET].trim(); } ////////////////// const tests = [ [0.0000000000001,2], [0.00000000001,2], [0.000000001,2], [0.000001,2], [0.001,2], [0.0016,2], [-0.0016,2], [0.01,2], [1,2], [999.99,2], [999.99,1], [-999.99,1], [999999,2], [999999999999,2], [999999999999999999,2], [99999999999999999999,2], ]; for (var i = 0; i < tests.length; i++) { console.log(abbreviateNumber(tests[i][0], tests[i][1]) ); }

通过消除@martin-sznapka解决方案中的循环，您将减少40%的执行时间。

function formatNum(num,digits) {
    let units = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
    let floor = Math.floor(Math.abs(num).toString().length / 3);
    let value=+(num / Math.pow(1000, floor))
    return value.toFixed(value > 1?digits:2) + units[floor - 1];

}

速度测试(200000随机样本)从这个线程不同的解决方案

Execution time: formatNum          418  ms
Execution time: kFormatter         438  ms it just use "k" no "M".."T" 
Execution time: beautify           593  ms doesnt support - negatives
Execution time: shortenLargeNumber 682  ms    
Execution time: Intl.NumberFormat  13197ms 

简单通用的方法

可以将COUNT_FORMATS配置对象设置为您想要的长度或长度，这取决于您测试的值范围。

// Configuration const COUNT_FORMATS = [ { // 0 - 999 letter: '', limit: 1e3 }, { // 1,000 - 999,999 letter: 'K', limit: 1e6 }, { // 1,000,000 - 999,999,999 letter: 'M', limit: 1e9 }, { // 1,000,000,000 - 999,999,999,999 letter: 'B', limit: 1e12 }, { // 1,000,000,000,000 - 999,999,999,999,999 letter: 'T', limit: 1e15 } ]; // Format Method: function formatCount(value) { const format = COUNT_FORMATS.find(format => (value < format.limit)); value = (1000 * value / format.limit); value = Math.round(value * 10) / 10; // keep one decimal number, only if needed return (value + format.letter); } // Test: const test = [274, 1683, 56512, 523491, 9523489, 5729532709, 9421032489032]; test.forEach(value => console.log(`${ value } >>> ${ formatCount(value) }`));