numberformat - ¿Cómo formatear un número como 2.5K si es mil o más, de lo contrario 900 en javascript?

numberformat javascript

Question

Necesito mostrar un valor de moneda en el formato de 1K de igual a mil, o 1.1K, 1.2K, 1.9K, etc., si no es un número par, de lo contrario si es menor de mil, muestra 500, 100, 250, etc. normales , usando javascript para formatear el número?

Answer 1

Dale crédito a Waylon Flinn si te gusta esto

Esto se mejoró desde su enfoque más elegante para manejar números negativos y el caso ".0".

Cuantos menos bucles y casos "si" tenga, mejor 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 con casos de prueba -> https://jsfiddle.net/xyug4nvz/7/

Answer 2

Agregando la respuesta superior, esto dará 1k por 1000 en lugar de 1.0k

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

Answer 3

Aquí hay una solución simple que evita todas las declaraciones if (con el poder de las Math ).

var SI_PREFIXES = ["", "k", "M", "G", "T", "P", "E"];
function abbreviateNumber(number){
// what tier? (determines SI prefix)
var tier = Math.log10(number) / 3 | 0;
// if zero, we don''t need a prefix
if(tier == 0) return number;
// get prefix and determine scale
var prefix = SI_PREFIXES[tier];
var scale = Math.pow(10, tier * 3);
// scale the number
var scaled = number / scale;
// format number and add prefix as suffix
return scaled.toFixed(1) + prefix;
}

Answer 4

Esta publicación es bastante antigua, pero de alguna manera llegué a esta publicación buscando algo. ASÍ PUEDO AGREGAR MI ENTRADA Numeral js es la solución única hoy en día. Proporciona una gran cantidad de métodos para ayudar a formatear los números

http://numeraljs.com/

Answer 5

Mejorando aún más la respuesta de @Yash con soporte de número negativo:

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 6

Mejorando aún más la respuesta de Salman porque devuelve nFormatter (33000) como 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;
}

ahora nFormatter (33000) = 33K

Answer 7

Parece que esto debería funcionar para ti:

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

Answer 8

Puede usar el paquete de d3-format basado en el formato de cadena avanzada de Python PEP3101 :

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

Answer 9

Una versión más generalizada:

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 10

esto es bastante elegante

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 11

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

Thx @Cos para comentar, eliminé la dependencia de Math.round10.

Answer 12

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