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