Отформатируйте число как 2.5K, если тысяча или больше, иначе 900

154

Мне нужно показать значение валюты в формате 1K, равное одной тысяче, или 1.1K, 1.2K, 1.9K и т. Д., Если это не четные тысячи, в противном случае, если число меньше тысячи, выведите обычные 500, 100, 250 и т. Д. , используя JavaScript для форматирования числа?

Карл Вейс
источник
2
Тебе тоже нужно Mи G?
Салман,
Мне понадобится М, да ... Вы можете помочь?
Карл Вейс

Ответы:

209

Похоже, это должно работать для вас:

function kFormatter(num) {
    return Math.abs(num) > 999 ? Math.sign(num)*((Math.abs(num)/1000).toFixed(1)) + 'k' : Math.sign(num)*Math.abs(num)
}
    
console.log(kFormatter(1200)); // 1.2k
console.log(kFormatter(-1200)); // -1.2k
console.log(kFormatter(900)); // 900
console.log(kFormatter(-900)); // -900

Джейк Физель
источник
2
Незначительное исправление предлагается ... Должно быть в нижнем регистре k для тысяч. Верх для килограмма. Пытался отредактировать, но требует как минимум 6 символов, измененных, прежде чем это займет.
Адам Янгерс
Как мне вставить переменную php внутри и использовать ее? т.е. если моя числовая переменная $mynumber_outputгде я могу вставить это, чтобы использовать его? Например, скажем $mynumber_output= 12846, я хотел бы преобразовать 12846 в12.8k
Обратите внимание, что в некоторых случаях один килобайт составляет 1024 байта: en.wikipedia.org/wiki/Kilobyte
Olle Härstedt
Любая идея, как мы можем сделать 1000 отображать как 1.0k вместо 1k?
Брент
1
Не полностью отвечает на вопрос пользователя. "Мне понадобится М, да ... Ты можешь помочь?" - Карл Вейс
tfmontague
217

Более обобщенная версия:

function nFormatter(num, digits) {
  var si = [
    { value: 1, symbol: "" },
    { value: 1E3, symbol: "k" },
    { value: 1E6, symbol: "M" },
    { value: 1E9, symbol: "G" },
    { value: 1E12, symbol: "T" },
    { value: 1E15, symbol: "P" },
    { value: 1E18, symbol: "E" }
  ];
  var rx = /\.0+$|(\.[0-9]*[1-9])0+$/;
  var i;
  for (i = si.length - 1; i > 0; i--) {
    if (num >= si[i].value) {
      break;
    }
  }
  return (num / si[i].value).toFixed(digits).replace(rx, "$1") + si[i].symbol;
}

/*
 * Tests
 */
var tests = [
  { num: 1234, digits: 1 },
  { num: 100000000, digits: 1 },
  { num: 299792458, digits: 1 },
  { num: 759878, digits: 1 },
  { num: 759878, digits: 0 },
  { num: 123, digits: 1 },
  { num: 123.456, digits: 1 },
  { num: 123.456, digits: 2 },
  { num: 123.456, digits: 4 }
];
var i;
for (i = 0; i < tests.length; i++) {
  console.log("nFormatter(" + tests[i].num + ", " + tests[i].digits + ") = " + nFormatter(tests[i].num, tests[i].digits));
}

Салман А
источник
@SalmanA - Отличная помощь, она не работает, если один проход arg в виде строки, если очистить с помощью parseFloat, работает хорошо. Спасибо!
Adesh M
1
Небольшое исправление для чисел меньше <1000, добавьте {значение: 1E0, символ: ""} к var si =
Dimmduh
1
@GiovanniAzua просто заменить if (num >= si[i].value)наif (Math.abs(num) >= si[i].value)
Салман А
что делает .replace(rx, "$1")?
М.Октавио
1
@ M.Octavio регулярное выражение используется, чтобы урезать конечные нули, например 1.0становится 1и 1.10становится1.1
Salman A
78

Вот простое решение, которое избегает всех ifутверждений (с силой Math).

var SI_SYMBOL = ["", "k", "M", "G", "T", "P", "E"];

function abbreviateNumber(number){

    // what tier? (determines SI symbol)
    var tier = Math.log10(number) / 3 | 0;

    // if zero, we don't need a suffix
    if(tier == 0) return number;

    // get suffix and determine scale
    var suffix = SI_SYMBOL[tier];
    var scale = Math.pow(10, tier * 3);

    // scale the number
    var scaled = number / scale;

    // format number and add suffix
    return scaled.toFixed(1) + suffix;
}

Бонус Мем

Что означает SI?

Waylon Flinn
источник
Мне очень нравится ваше решение. Чтобы иметь возможность сокращать и отрицательные значения, я умножаю число на -1 до и после определения уровня, поскольку Math.log10 (absoluteValue) будет возвращать NaN.
xhadon
Просто используйте , Math.absчтобы добавить поддержку отрицательных чисел, например , что: var tier = Math.log10(Math.abs(number)) / 3 | 0;.
Кайо Тарифа
71

Дальнейшее улучшение ответа Салмана, потому что он возвращает nFormatter (33000) как 33.0K

function nFormatter(num) {
     if (num >= 1000000000) {
        return (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'G';
     }
     if (num >= 1000000) {
        return (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
     }
     if (num >= 1000) {
        return (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
     }
     return num;
}

сейчас nFormatter (33000) = 33K

Яши
источник
2
В любом случае, чтобы сделать это без округления числа? 1,590,000 вернут 1,6M.
Бретт Хардин
3
Иногда трудно понять, когда публиковать новый ответ или отредактировать существующий, поэтому я принимаю решение, если я украду код из ответа другого пользователя, я обычно редактирую его ответ, чтобы они могли получить признание, а не я воровал их. код.
MH
@ Да, ты код, который я пытаюсь реализовать в скрипте счетчика, но не получаю его, это моя ссылка на codepen codeio.io/Merajkhan/pen/MMoxGE?editors=1010 Можете ли вы помочь мне, как реализовать эту логику, которую я хочу К, L, M единицы должны прийти.
Мехрадж Хан
Отлично. Короткое и сладкое решение.
Хасита Джаявардана
22
/**
 * Shorten number to thousands, millions, billions, etc.
 * http://en.wikipedia.org/wiki/Metric_prefix
 *
 * @param {number} num Number to shorten.
 * @param {number} [digits=0] The number of digits to appear after the decimal point.
 * @returns {string|number}
 *
 * @example
 * // returns '12.5k'
 * shortenLargeNumber(12543, 1)
 *
 * @example
 * // returns '-13k'
 * shortenLargeNumber(-12567)
 *
 * @example
 * // returns '51M'
 * shortenLargeNumber(51000000)
 *
 * @example
 * // returns 651
 * shortenLargeNumber(651)
 *
 * @example
 * // returns 0.12345
 * shortenLargeNumber(0.12345)
 */
function shortenLargeNumber(num, digits) {
    var units = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'],
        decimal;

    for(var i=units.length-1; i>=0; i--) {
        decimal = Math.pow(1000, i+1);

        if(num <= -decimal || num >= decimal) {
            return +(num / decimal).toFixed(digits) + units[i];
        }
    }

    return num;
}

Спасибо за комментарий, я удалил Math.round10 зависимость.

Мартин Шнапка
источник
1
Вы можете изменить, если на Math.abs(num) >= decimal.
Конор Пендер
18

Многие ответы в этом потоке становятся довольно сложными, с использованием объектов Math, объектов карты, циклов for, регулярных выражений и т. Д. Но эти подходы на самом деле не улучшают читабельность кода или производительность. Прямой подход, кажется, предлагает лучший дизайн.

Форматирование денежного значения с помощью K

const formatCash = n => {
  if (n < 1e3) return n;
  if (n >= 1e3) return +(n / 1e3).toFixed(1) + "K";
};

console.log(formatCash(2500));

Форматирование денежной суммы с помощью KMBT

const formatCash = n => {
  if (n < 1e3) return n;
  if (n >= 1e3 && n < 1e6) return +(n / 1e3).toFixed(1) + "K";
  if (n >= 1e6 && n < 1e9) return +(n / 1e6).toFixed(1) + "M";
  if (n >= 1e9 && n < 1e12) return +(n / 1e9).toFixed(1) + "B";
  if (n >= 1e12) return +(n / 1e12).toFixed(1) + "T";
};

console.log(formatCash(1235000));

Используя отрицательные числа

let format;
const number = -1235000;

if (number < 0) {
  format = '-' + formatCash(-1 * number);
} else {
  format = formatCash(number);
}
tfmontague
источник
1
@Jan - обновил мой пост с примером, но чувствовал, что было достаточно просто вычислить отрицательную форму, используя'-' + formatCash(-1 * number)
tfmontague
15

Дайте кредит Уэйлону Флинну, если вам это нравится

Это было улучшено благодаря его более элегантному подходу к обработке отрицательных чисел и кейсу «.0».

Чем меньше у вас циклов и случаев «если», тем лучше ИМО.

function abbreviateNumber(number) {
    var SI_POSTFIXES = ["", "k", "M", "G", "T", "P", "E"];
    var tier = Math.log10(Math.abs(number)) / 3 | 0;
    if(tier == 0) return number;
    var postfix = SI_POSTFIXES[tier];
    var scale = Math.pow(10, tier * 3);
    var scaled = number / scale;
    var formatted = scaled.toFixed(1) + '';
    if (/\.0$/.test(formatted))
      formatted = formatted.substr(0, formatted.length - 2);
    return formatted + postfix;
}

jsFiddle с тестовыми примерами -> https://jsfiddle.net/xyug4nvz/7/

Джейсон Себринг
источник
1
Там все еще раздражающая ошибка: abbreviateNumber(999999) == '1000k'вместо '1M'. Это потому, что toFixed()также округляет числа. Не уверен, как это исправить, хотя: /
Vitor Baptista
@VitorBaptista Если toFixed()число округляется в любом случае, вы также можете округлить число перед отправкой abbreviateNumber(), поэтому оно возвращается 1Mвместо 1000k. Не решение, а обходной путь.
forsureitsme
2
Если вы не хотите округления, вы можете сделать это после шага масштабирования:const floored = Math.floor(scaled * 10) / 10;
tybro0103
14

ES2020 добавляет поддержку для этого в Intl.NumberFormatиспользовании нотации следующим образом:

console.log(Intl.NumberFormat('en-US', { notation: "compact" , compactDisplay: "short" }).format(987654321));

NumberFormat спецификации:

Обратите внимание, что в настоящее время не все браузеры поддерживают ES2020, поэтому вам может понадобиться этот Polyfill: https://formatjs.io/docs/polyfills/intl-numberformat

Ори Прайс
источник
Этот пакет устарел, поэтому воспользуйтесь этой ссылкой: npmjs.com/package/@formatjs/intl-numberformat
Аммад Халид
2
Примечание: Chrome поддерживает notationи, compactDisplayно FireFox 77 и Safari 13.1 по-прежнему не поддерживают его, поэтому вам, вероятно, понадобится полифилл.
Джош Унгер
Ого, Firefox только что добавил поддержку в версии 78, кажется. Конечно, через 2 с лишним года этот комментарий будет выглядеть глупо. : P (хотя мне это смешно, потому что код запускается для меня, но он не конвертируется должным образом, поэтому мне нужно будет сделать обновление.)
Андрей
11

это довольно элегантно.

function formatToUnits(number, precision) {
  const abbrev = ['', 'k', 'm', 'b', 't'];
  const unrangifiedOrder = Math.floor(Math.log10(Math.abs(number)) / 3)
  const order = Math.max(0, Math.min(unrangifiedOrder, abbrev.length -1 ))
  const suffix = abbrev[order];

  return (number / Math.pow(10, order * 3)).toFixed(precision) + suffix;
}

formatToUnits(12345, 2)
==> "12.35k"
formatToUnits(0, 3)
==> "0.000"
Novellizator
источник
4

Вы можете использовать пакет формата d3 , смоделированный после расширенного форматирования строк Python PEP3101 :

var f = require('d3-format')
console.log(f.format('.2s')(2500)) // displays "2.5k"
Винсент де Лагаббе
источник
3

Дальнейшее улучшение ответа @ 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"
клубника
источник
3

Этот пост довольно старый, но я как-то дошел до этого поста в поисках чего-то. Поэтому, чтобы добавить мой ввод, Numeral js - это единственное решение в наши дни. Это дает большое количество методов, чтобы помочь форматированию чисел

http://numeraljs.com/

Vatsal
источник
1
цифра больше не поддерживается. Самая активная вилка, кажется, Numbro . Но ни один из них не поддерживает SI / метрическую нотацию
Винсент де Лагаббе
2

Краткий и общий метод

Вы можете сделать 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) }`));

Джил Эпштейн
источник
1

Если добавить верхний ответ, это даст 1к на 1000 вместо 1,0к

function kFormatter(num) {
    return num > 999 ? num % 1000 === 0 ? (num/1000).toFixed(0) + 'k' : (num/1000).toFixed(1) + 'k' : num
}
rajatbarman
источник
1

Модифицированная версия ответа Уэйлона Флинна с поддержкой отрицательных показателей:

function metric(number) {

  const SI_SYMBOL = [
    ["", "k", "M", "G", "T", "P", "E"], // +
    ["", "m", "μ", "n", "p", "f", "a"] // -
  ];

  const tier = Math.floor(Math.log10(Math.abs(number)) / 3) | 0;

  const n = tier < 0 ? 1 : 0;

  const t = Math.abs(tier);

  const scale = Math.pow(10, tier * 3);

  return {
    number: number,
    symbol: SI_SYMBOL[n][t],
    scale: scale,
    scaled: number / scale
  }
}

function metric_suffix(number, precision) {
  const m = metric(number);
  return (typeof precision === 'number' ? m.scaled.toFixed(precision) : m.scaled) + m.symbol;
}

for (var i = 1e-6, s = 1; i < 1e7; i *= 10, s *= -1) {
  // toggles sign in each iteration
  console.log(metric_suffix(s * (i + i / 5), 1));
}

console.log(metric(0));

Ожидаемый результат:

   1.2μ
 -12.0μ
 120.0μ
  -1.2m
  12.0m
-120.0m
   1.2
 -12.0
 120.0
  -1.2k
  12.0k
-120.0k
   1.2M
{ number: 0, symbol: '', scale: 1, scaled: 0 }
Thalionâth
источник
1
  • Поддержка отрицательного числа
  • Проверка на !Number.isFinite
  • Измените ' K M G T P E Z Y'на, ' K M'если вы хотите, чтобы максимальная единица былаM

Ниже код 1K = 1024, если вы хотите 1K = 1000, измените все 1024 на 1000.


Number.prototype.prefix = function (precision = 2) {

    var units = ' K M G T P E Z Y'.split(' ');

    if (this < 0) {
        return '-' + Math.abs(this).prefix(precision);
    }

    if (this < 1) {
        return this + units[0];
    }

    var power = Math.min(
        Math.floor(Math.log(this) / Math.log(1024)),
        units.length - 1
    );

    return (this / Math.pow(1024, power)).toFixed(precision) + units[power];
}

console.log('10240 = ' + (10240).prefix()) // 10.00K
console.log('1234000 = ' + (1234000).prefix(1)) // 1.2M
console.log('10000 = ' + (-10000).prefix()) // -9.77K

Steely Wing
источник
(11000) .prefix () равно 10.74K, не очень точно следует сказать 11.00K
bmaggi
1
@bmaggi Просто измените 1024 на 1000
Steely Wing
1

Улучшение ответа @ tfmontague для форматирования десятичных знаков. 33.0к до 33к

largeNumberFormatter(value: number): any {
   let result: any = value;

   if (value >= 1e3 && value < 1e6) { result = (value / 1e3).toFixed(1).replace(/\.0$/, '') + 'K'; }
   if (value >= 1e6 && value < 1e9) { result = (value / 1e6).toFixed(1).replace(/\.0$/, '') + 'M'; }
   if (value >= 1e9) { result = (value / 1e9).toFixed(1).replace(/\.0$/, '') + 'T'; }

   return result;
}
Абдул Рахман
источник
1

Не устраивает ни одно из опубликованных решений, поэтому вот моя версия:

  1. Поддерживает положительные и отрицательные числа
  2. Поддерживает отрицательные показатели
  3. Округляет до следующего показателя, если это возможно
  4. Выполняет проверку границ (не выдает ошибку для очень больших / маленьких чисел)
  5. Снимает конечные нули / пробелы
  6. Поддерживает параметр точности

    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]) );
    }

TTK
источник
1

Я придумал очень кодовый гольф, и он очень короткий!

var beautify=n=>((Math.log10(n)/3|0)==0)?n:Number((n/Math.pow(10,(Math.log10(n)/3|0)*3)).toFixed(1))+["","K","M","B","T",][Math.log10(n)/3|0];

console.log(beautify(1000))
console.log(beautify(10000000))

Craftingexpert1
источник
1

Дальнейшее улучшение ответа Салмана из-за таких случаев, как nFormatter (999999,1), который возвращает 1000K.

function formatNumberWithMetricPrefix(num, digits = 1) {
  const si = [
    {value: 1e18, symbol: 'E'},
    {value: 1e15, symbol: 'P'},
    {value: 1e12, symbol: 'T'},
    {value: 1e9, symbol: 'G'},
    {value: 1e6, symbol: 'M'},
    {value: 1e3, symbol: 'k'},
    {value: 0, symbol: ''},
  ];
  const rx = /\.0+$|(\.[0-9]*[1-9])0+$/;
  function divideNum(divider) {
    return (num / (divider || 1)).toFixed(digits);
  }

  let i = si.findIndex(({value}) => num >= value);
  if (+divideNum(si[i].value) >= 1e3 && si[i - 1]) {
    i -= 1;
  }
  const {value, symbol} = si[i];
  return divideNum(value).replace(rx, '$1') + symbol;
}
Подвальный Михаил
источник
1

Самый простой и легкий способ сделать это

new Intl.NumberFormat('en-IN', { 
    notation: "compact",
    compactDisplay: "short",
    style: 'currency',
    currency: 'INR'
}).format(1000).replace("T", "K")

Это работает для любого числа. В том числе L Crи т. Д.

Нарасимха Редди - Компьютерщик
источник
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 
Feras
источник
0
/*including negative values*/    
function nFormatter(num) {
      let neg = false;
       if(num < 0){
         num = num * -1;
         neg = true;
       }
       if (num >= 1000000000) {
         if(neg){
           return -1 * (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'G';  
         }
         return (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'G';
       }
       if (num >= 1000000) {
         if(neg){
           return -1 * (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';  
         }
         return (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
       }
       if (num >= 1000) {
         if(neg){
           return -1 * (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K';  
         }
         return (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
       }
       return num;
    }
Вивек Кумават
источник
Пожалуйста, добавьте некоторые объяснения вашего решения
Харун Дилука Хешан
0

Эта функция может преобразовать огромные числа (как положительные, так и отрицательные) в удобный для чтения формат без потери точности:

function abbrNum(n) {
    if (!n || (n && typeof n !== 'number')) {
      return '';
    }

    const ranges = [
      { divider: 1e12 , suffix: 't' },
      { divider: 1e9 , suffix: 'b' },
      { divider: 1e6 , suffix: 'm' },
      { divider: 1e3 , suffix: 'k' }
    ];
    const range = ranges.find(r => Math.abs(n) >= r.divider);
    if (range) {
      return (n / range.divider).toString() + range.suffix;
    }
    return n.toString();
}

/* test cases */
let testAry = [99, 1200, -150000, 9000000];
let resultAry = testAry.map(abbrNum);
console.log("result array: " + resultAry);

Хамзин Хамим
источник
0

Я использую эту функцию. Это работает для обоих phpи javascript.

    /**
     * @param $n
     * @return string
     * Use to convert large positive numbers in to short form like 1K+, 100K+, 199K+, 1M+, 10M+, 1B+ etc
     */
 function num_format($n) {
        $n_format = null;
        $suffix = null;
        if ($n > 0 && $n < 1000) {
           $n_format = Math.floor($n);   
            $suffix = '';
        }
        else if ($n == 1000) {
            $n_format = Math.floor($n / 1000);   //For PHP only use floor function insted of Math.floor()
            $suffix = 'K';
        }
        else if ($n > 1000 && $n < 1000000) {
            $n_format = Math.floor($n / 1000);
            $suffix = 'K+';
        } else if ($n == 1000000) {
            $n_format = Math.floor($n / 1000000);
            $suffix = 'M';
        } else if ($n > 1000000 && $n < 1000000000) {
            $n_format = Math.floor($n / 1000000);
            $suffix = 'M+';
        } else if ($n == 1000000000) {
            $n_format = Math.floor($n / 1000000000);
            $suffix = 'B';
        } else if ($n > 1000000000 && $n < 1000000000000) {
            $n_format = Math.floor($n / 1000000000);
            $suffix = 'B+';
        } else if ($n == 1000000000000) {
            $n_format = Math.floor($n / 1000000000000);
            $suffix = 'T';
        } else if ($n >= 1000000000000) {
            $n_format = Math.floor($n / 1000000000000);
            $suffix = 'T+';
        }


       /***** For PHP  ******/
       //  return !empty($n_format . $suffix) ? $n_format . $suffix : 0;

       /***** For Javascript ******/
        return ($n_format + $suffix).length > 0 ? $n_format + $suffix : 0;
    }
шах
источник
0

Я решил подробно рассказать об ответе @ Novellizator, чтобы удовлетворить мои потребности. Я хотел гибкую функцию, чтобы справиться с большинством моих потребностей форматирования без внешних библиотек.

Характеристики

  • Возможность использовать суффиксы заказа (k, M и т. Д.)
    • Возможность указать собственный список суффиксов заказа для использования
    • Возможность ограничения минимального и максимального порядка
  • Контроль количества десятичных знаков
  • Автоматическое разделение запятых
  • Необязательное процентное или долларовое форматирование
  • Контроль над тем, что возвращать в случае нечислового ввода
  • Работает на отрицательных и бесконечных числах

Примеры

let x = 1234567.8;
formatNumber(x);  // '1,234,568'
formatNumber(x, {useOrderSuffix: true});  // '1M'
formatNumber(x, {useOrderSuffix: true, decimals: 3, maxOrder: 1});  // '1,234.568k'
formatNumber(x, {decimals: 2, style: '$'});  // '$1,234,567.80'

x = 10.615;
formatNumber(x, {style: '%'});  // '1,062%'
formatNumber(x, {useOrderSuffix: true, decimals: 1, style: '%'});  // '1.1k%'
formatNumber(x, {useOrderSuffix: true, decimals: 5, style: '%', minOrder: 2});  // '0.00106M%'

formatNumber(-Infinity);  // '-∞'
formatNumber(NaN);  // ''
formatNumber(NaN, {valueIfNaN: NaN});  // NaN

функция

/*
 * Return the given number as a formatted string.  The default format is a plain
 * integer with thousands-separator commas.  The optional parameters facilitate
 * other formats:
 *   - decimals = the number of decimals places to round to and show
 *   - valueIfNaN = the value to show for non-numeric input
 *   - style
 *     - '%': multiplies by 100 and appends a percent symbol
 *     - '$': prepends a dollar sign
 *   - useOrderSuffix = whether to use suffixes like k for 1,000, etc.
 *   - orderSuffixes = the list of suffixes to use
 *   - minOrder and maxOrder allow the order to be constrained.  Examples:
 *     - minOrder = 1 means the k suffix should be used for numbers < 1,000
 *     - maxOrder = 1 means the k suffix should be used for numbers >= 1,000,000
 */
function formatNumber(number, {
    decimals = 0,
    valueIfNaN = '',
    style = '',
    useOrderSuffix = false,
    orderSuffixes = ['', 'k', 'M', 'B', 'T'],
    minOrder = 0,
    maxOrder = Infinity
  } = {}) {

  let x = parseFloat(number);

  if (isNaN(x))
    return valueIfNaN;

  if (style === '%')
    x *= 100.0;

  let order;
  if (!isFinite(x) || !useOrderSuffix)
    order = 0;
  else if (minOrder === maxOrder)
    order = minOrder;
  else {
    const unboundedOrder = Math.floor(Math.log10(Math.abs(x)) / 3);
    order = Math.max(
      0,
      minOrder,
      Math.min(unboundedOrder, maxOrder, orderSuffixes.length - 1)
    );
  }

  const orderSuffix = orderSuffixes[order];
  if (order !== 0)
    x /= Math.pow(10, order * 3);

  return (style === '$' ? '$' : '') +
    x.toLocaleString(
      'en-US',
      {
        style: 'decimal',
        minimumFractionDigits: decimals,
        maximumFractionDigits: decimals
      }
    ) +
    orderSuffix +
    (style === '%' ? '%' : '');
}
MarredCheese
источник
0

Вау, здесь так много ответов. Я подумал, что расскажу вам, как я решил эту проблему, так как она кажется самой простой для чтения, обрабатывает отрицательные числа и выходит далеко в диапазоне килограммов для JavaScript. Также было бы легко изменить то, что вы хотите, или расширить еще дальше.

const symbols = [
  { value: 1, symbol: '' },
  { value: 1e3, symbol: 'k' },
  { value: 1e6, symbol: 'M' },
  { value: 1e9, symbol: 'G' },
  { value: 1e12, symbol: 'T' },
  { value: 1e15, symbol: 'P' },
  { value: 1e18, symbol: 'E' }
];

function numberFormatter(num, digits) {
  const numToCheck = Math.abs(num);
  for (let i = symbols.length - 1; i >= 0; i--) {
    if (numToCheck >= symbols[i].value) {
      const newNumber = (num / symbols[i].value).toFixed(digits);
      return `${newNumber}${symbols[i].symbol}`;
    }
  }
  return '0';
}

const tests = [
  { num: 1234, digits: 1 },
  { num: 100000000, digits: 1 },
  { num: 299792458, digits: 1 },
  { num: 759878, digits: 1 },
  { num: -759878, digits: 0 },
  { num: 123, digits: 1 },
  { num: 123.456, digits: 1 },
  { num: -123.456, digits: 2 },
  { num: 123.456, digits: 4 }
];
for (let i = 0; i < tests.length; i++) {
  console.log(`numberFormatter(${tests[i].num}, ${tests[i].digits})=${numberFormatter(tests[i].num, tests[i].digits)}`);
}

Дж. Т. Тернер
источник
0

Более короткая альтернатива:

function nFormatter(num) {
    const format = [
      { value: 1e18, symbol: 'E' },
      { value: 1e15, symbol: 'P' },
      { value: 1e12, symbol: 'T' },
      { value: 1e9, symbol: 'G' },
      { value: 1e6, symbol: 'M' },
      { value: 1e3, symbol: 'k' },
      { value: 1, symbol: '' },
    ];
    const formatIndex = format.findIndex((data) => num >= data.value);
    console.log(formatIndex)
    return (num / format[formatIndex === -1? 6: formatIndex].value).toFixed(2) + format[formatIndex === -1?6: formatIndex].symbol;
  }
  

wkwkwk
источник