दिलचस्प पोस्ट
सीएसएस दृश्यता काम क्यों नहीं कर रही है? फ़ंक्शन नाम के सामने जावास्क्रिप्ट प्लस चिह्न .zip से ग्रहण के लिए प्लग इन कैसे स्थापित करें AngularJS गतिशील रूटिंग आइटम्स कंट्रोल में आइटम्स के बीच एक विभाजक कैसे जोड़ा जा सकता है Asp.net mvc में नियंत्रक को सरल अजाक्स कॉल करना सरल html dom file_get_html काम नहीं कर रहा है – क्या कोई वैकल्पिक हल है? स्विफ्ट 3.0 में यूआईवीआईयूईई () कंस्ट्रक्टर का क्या हुआ? गर्तिका स्वीकार – "बहुत अधिक खुली फ़ाइलें" कैसे ggplot में पहलू अनुपात को ठीक करने के लिए? एक ही बात करने के लिए यूआरएल पर लूपिंग सी पूर्णांक के nth बाइट प्राप्त करें jqgrid: multiselect और अक्षम चेक (सशर्त) सी # में स्ट्रिंग और स्ट्रिंग के बीच अंतर क्या है? WPF में एक बटन पर माउसऑवर प्रभाव कैसे अक्षम करते हैं?

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

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

Solutions Collecting From Web of "एक संख्या को 2.5K के रूप में कैसे प्रारूपित करें, यदि एक हजार या अधिक, अन्यथा 900 जावास्क्रिप्ट में?"

ऐसा लगता है कि आपके लिए यह काम करना चाहिए:

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

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

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

इसके अलावा सलमान के जवाब में सुधार क्योंकि यह 33.0 के रूप में एनएफॉर्ममेंट (33000) को वापस करता है

 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

यहाँ एक सरल समाधान है जो सभी if बयानों ( 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; } 
 /** * 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, मैंने मैथ .10 निर्भरता को हटा दिया।

अगर आपको यह पसंद है तो वेन फ्लिन को क्रडिट दें

यह नकारात्मक संख्याओं और ".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/

नकारात्मक संख्या के समर्थन के साथ @ यश की उत्तर में सुधार:

 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" 

आप पायथन उन्नत स्ट्रिंग फ़ॉर्मेटिंग PEP3101 के बाद modeled d3-format पैकेज का उपयोग कर सकते हैं:

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

यह पोस्ट काफी पुरानी है लेकिन मैं किसी तरह कुछ के लिए खोज करने के लिए इस पोस्ट पर पहुंच गया। अतः मेरा इनपुट संख्या जोड़ने के लिए अंक जेएस एक दिन एक स्टॉप समाधान है। यह संख्याओं को स्वरूपित करने में सहायता करने के लिए कई तरीकों को देता है

http://numeraljs.com/

शीर्ष उत्तर पर जोड़ना, यह 1.0k के बजाय 1,000 के लिए 1k देगा

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