संख्या को 2.5K के रूप में प्रारूपित करें यदि एक हजार या अधिक, अन्यथा 900

152

मुझे 1K के प्रारूप में एक हज़ार के बराबर, या 1.1K, 1.2K, 1.9K इत्यादि के रूप में एक मुद्रा मूल्य दिखाने की आवश्यकता है, अगर इसकी एक हजार भी नहीं तो, अन्यथा यदि एक हज़ार के तहत, सामान्य 500, 100, 250 आदि प्रदर्शित करें। , जावास्क्रिप्ट का उपयोग कर संख्या को प्रारूपित करने के लिए?

javascript  jquery  formatting  numbers 
— कार्ल वीस
स्रोत
2
क्या आपको भी चाहिए Mऔर G?
— सलमान ए
मुझे एम हां की आवश्यकता होगी ... क्या आप मदद कर सकते हैं?
— कार्ल वीस
2
— मैजिट्रेट

जवाबों:

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
— ओलले हर्स्टेड्ट
कोई भी विचार कि हम 1k के बजाय 1000k को 1.0k कैसे बना सकते हैं?
— ब्रेंट
1
पूरी तरह से उपयोगकर्ता के सवाल का जवाब नहीं देता है। "मुझे एम की आवश्यकता होगी हाँ ... क्या आप मदद कर सकते हैं?" - कार्ल वीस
— tfmontague 22
216

एक अधिक सामान्यीकृत संस्करण:

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));
}
स्निपेट का विस्तार करें

— सलमान ए
स्रोत
@ सलमान - बहुत मदद, यह विफल हो जाता है अगर एक पास स्ट्रिंग के रूप में आता है, अगर parseFloat के साथ सफाई अच्छी तरह से काम करती है। धन्यवाद!
— आदेश M
1
संख्याओं के लिए छोटा फिक्स <1000, {value जोड़ें: 1E0, प्रतीक: ""} से var si =
— Dimmduh
1
@ गोविन्नीअज़ुआ बस के if (num >= si[i].value)साथif (Math.abs(num) >= si[i].value)
— सलमान ए
क्या करता .replace(rx, "$1")है?
— एम। ओक्टावियो
1
@ M.Octavio regex का उपयोग ट्रेलिंग शून्य को ट्रिम करने के लिए किया 1.0जाता है। जैसे 1और 1.10बन जाता है1.1
— सलमान 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खड़ा है?

— वायलन फ़्लिन
स्रोत
मुझे वास्तव में आपका समाधान पसंद है। साथ ही नकारात्मक मानों को छोटा करने में सक्षम होने के लिए, मैं संख्या को -1 से गुणा करने से पहले और उसके बाद टियर का निर्धारण करता हूं, क्योंकि Math.log10 (negativeValue) NaN को लौटा देगा।
— xhadon
बस Math.absनकारात्मक संख्याओं को समर्थन जोड़ने के लिए उपयोग करें, जैसे var tier = Math.log10(Math.abs(number)) / 3 | 0;:।
— कैयो टरीफा
70

सलमान के उत्तर में और सुधार करते हुए क्योंकि यह 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
@ यश आप वह कोड हैं जिसे मैं काउंटर स्क्रिप्ट में लागू करने की कोशिश कर रहा हूं, लेकिन यह नहीं मिल रहा है यह मेरा कोडपेन लिंक कोडपेन है ।io/Merajkhan/pen/MMoxGE?editors=1010 क्या आप इस तर्क को लागू करने में मेरी मदद कर सकते हैं। के, एल, एम इकाइयों को आना होगा।
— महराज खान
महान। शार्ट एंड स्वीट सॉल्यूशन।
— हसीथा जयवर्धना
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;
}

टिप्पणी के लिए Thx @Cos, मैंने Math.round10 निर्भरता को हटा दिया।

— मार्टिन सजनपका
स्रोत
1
यदि आप को बदल सकते हैं Math.abs(num) >= decimal।
— कोनोर पेंडर
18

मैथ ऑब्जेक्ट्स, मैप ऑब्जेक्ट्स, फॉर-लूप्स, रेगेक्स आदि का उपयोग करके इस थ्रेड पर बहुत सारे उत्तर जटिल हो जाते हैं, लेकिन ये दृष्टिकोण वास्तव में कोड की पठनीयता, या प्रदर्शन में सुधार नहीं करते हैं। एक सीधा आगे का दृष्टिकोण सबसे अच्छा डिजाइन प्रदान करता है।

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()यह संख्याओं को भी गोल करता है। यह निश्चित नहीं है कि इसे कैसे ठीक किया जाए, हालांकि: /
— विटोर बैप्टिस्टा
@VitorBaptista toFixed()वैसे भी संख्या को गोल करता है abbreviateNumber(), तो आप इसे भेजने से पहले संख्या को गोल कर सकते हैं , इसलिए यह 1Mइसके बजाय वापस आ जाता है 1000k। समाधान नहीं, बल्कि समाधान है।
— १२:
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 अभी भी इसका समर्थन नहीं करते हैं, इसलिए आपको पॉलीफ़िल की आवश्यकता होगी।
— जोश अनगर
वाह, फ़ायरफ़ॉक्स सिर्फ समर्थन इस के लिए वी। 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
स्रोत
3

नकारात्मक संख्या समर्थन के साथ यश के जवाब में और सुधार:

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

यह पोस्ट काफी पुरानी है लेकिन मैं किसी तरह इस पोस्ट तक कुछ खोजता हुआ पहुँचा। तो मेरे इनपुट को जोड़ने के लिए न्यूमरल js एक स्टॉप सॉल्यूशन है अब एक दिन। यह संख्याओं को प्रारूपित करने में मदद करने के लिए बड़ी संख्या में तरीके देता है

http://numeraljs.com/

— वत्सल
स्रोत
1
numeraljs का रखरखाव अब नहीं किया जाता है। सबसे सक्रिय कांटा सुन्न प्रतीत होता है । लेकिन उनमें से कोई भी 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.0k के बजाय 1000 के लिए 1k देगा

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
स्निपेट का विस्तार करें

— स्टेली विंग
स्रोत
(११०००)। उपसर्ग () १०. not४ के बराबर होता है बहुत सटीक नहीं कहना चाहिए ११.०० के
— बाम्गी
1
@bmaggi बस 1024 से 1000 तक बदल दें
— स्टीली विंग
1

दशमलव स्थानों को प्रारूपित करने के लिए @ tfmontague के उत्तर को और बेहतर बनाना। 33.0k से 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;
}
— अब्दुल रहमान
स्रोत
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]) );
}
    स्निपेट का विस्तार करें

— टीटीके
स्रोत
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;
    }
— विवेक कुमावत
स्रोत
pls अपने हल के कुछ स्पष्टीकरण जोड़ें
— हारुन दिलुका हेशन
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

वाह यहाँ पर बहुत सारे उत्तर हैं। मुझे लगा कि मैं आपको दे दूंगा कि मैंने इसे कैसे हल किया क्योंकि यह पढ़ने में सबसे आसान लग रहा था, नकारात्मक संख्याओं को संभालता है, और जावास्क्रिप्ट के लिए किलो नंबर रेंज में बहुत दूर निकल जाता है। यह भी बदलना आसान होगा कि आप क्या चाहते हैं या आगे भी बढ़ा सकते हैं।

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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.