Format the number as 2.5K if a thousand or more, otherwise 900

Question

I need to show a currency value in 1K format equal to one thousand, or 1.1K, 1.2K, 1.9K, etc., if it is not equal to thousands, otherwise, if less than a thousand, display the normal 500, 100, 250 etc. Using javascript to format the number?

Answer 1

Seems like this should work for you:

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 

Answer 2

More generalized version:

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

Answer 3

Further improvement of Salman Answer because it returns nFormatter (33000) as 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; } 

now nFormatter (33000) = 33K

Answer 4

Here's a simple solution that avoids all if (with the power of 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; } 

Bonus Mem

What does SI mean?

Answer 5

 /** * 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; } 

thanks @Cos for comments, I removed the Math.round10 dependency.

Answer 6

Give credit to Waylon Flinn if you like it

This has been improved out of his more elegant approach for handling negative numbers and the ".0" case.

The fewer cycles and if-cases you have, the better IMO.

 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 with test cases -> https://jsfiddle.net/xyug4nvz/7/

Answer 7

It is quite elegant.

 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" 

Answer 8

Many of the answers in this thread become quite complex, using Math objects, map objects, for loops, regular expressions, etc. But these approaches do not actually improve code readability or performance. A direct approach seems to offer the best design.

Format monetary value with K

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

Format monetary value using 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)); 

Answer 9

Further improving @Yash's answer with negative number support:

 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" 

Answer 10

You can use the d3-format package modeled after formatting Python's formatted string PEP3101 :

 var f = require('d3-format') console.log(f.format('.2s')(2500)) // displays "2.5k" 

Answer 11

This post is pretty old, but somehow I got to this post looking for something. SO to add my input. Numeral js is a one-stop solution now in a few days. It provides a large number of methods to help format numbers.

http://numeraljs.com/

Answer 12

Adding a top answer, this will give 1k for 1000 instead of 1.0k

 function kFormatter(num) { return num > 999 ? num % 1000 === 0 ? (num/1000).toFixed(0) + 'k' : (num/1000).toFixed(1) + 'k' : num } 

Answer 13

• Negative Number Support
• Check for !Number.isFinite
• Change ' KMGTPEZ Y' to ' K M' if you want the maximum unit to be M

Below is the code 1K = 1024, if you want 1K = 1000, change all 1024 to 1000.

---

 Number.prototype.prefix = function (precision = 2) { var units = ' KMGTPEZ 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 

Answer 14

Improved @tfmontague answer for decimal formatting. 33.0k to 33k

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

Answer 15

 /*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; } 

Answer 16

A modified version of Waylon Flinn's answer with support for negative metrics:

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

Expected Result:

  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 } 

Answer 17

This function can convert huge numbers (both positive and negative) into a readable format without loss of precision:

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

Answer 18

I am using this feature. This works for both php and 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; } 

Answer 19

I decided to talk in detail about @Novellizator's answer to meet my needs. I wanted a flexible function to handle most of my formatting needs without external libraries.

Characteristics

• Ability to use order suffixes (k, M, etc.)
  • Ability to specify your own list of order suffixes to use
  • Ability to limit the minimum and maximum order
• Decimal number control
• Automatic comma separation
• Optional percentage or dollar formatting
• Control over what to return in case of non-numeric input
• Works on negative and infinite numbers

Examples

 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 

function

 /* * 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 === '%' ? '%' : ''); } 

Answer 20

Wow, there are so many answers. I thought I was going to tell you how I solved this problem, as it seems the easiest to read, processes negative numbers and goes far in the kilogram range for JavaScript. It would also be easy to change what you want, or expand even further.

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

Answer 21

None of the published solutions are satisfied, so here is my version:

1. Supports positive and negative numbers
2. Supports Negative Performance
3. If possible, round to the next indicator.
4. Performs border checks (does not throw errors for very large / small numbers)
5. Remove trailing zeros / spaces

6. Supports precision setting

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