আমাকে এক হাজারের সমতুল্য 1K বা 1.1K, 1.2K, 1.9K ইত্যাদি আকারে একটি মুদ্রার মানটি দেখাতে হবে, যদি এটি হাজার হাজার না হয়, অন্যথায় যদি হাজারের অধীনে থাকে তবে স্বাভাবিক 500, 100, 250 ইত্যাদি প্রদর্শন করুন , জাভাস্ক্রিপ্ট ব্যবহার করে নম্বর ফর্ম্যাট করতে?
উত্তর:
এর মতো শব্দগুলি আপনার পক্ষে কাজ করা উচিত:
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$mynumber_outputএটি ব্যবহারের জন্য আমি এটি কোথায় সন্নিবেশ করবো? উদাহরণস্বরূপ, বলুন $mynumber_output= 12846, আমি 12846 রূপান্তর করতে চাই12.8k
আরও সাধারণ সংস্করণ:
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));
}if (num >= si[i].value)সঙ্গেif (Math.abs(num) >= si[i].value)
.replace(rx, "$1")?
1.0হয়ে 1এবং 1.10হয়ে1.1
এখানে একটি সহজ সমাধান যা সমস্ত 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;
}Math.absঋণাত্মক সংখ্যা সমর্থন যোগ করার জন্য, যে ভালো: var tier = Math.log10(Math.abs(number)) / 3 | 0;।
সালমানের জবাব আরও উন্নতি করে কারণ এটি এনফর্ম্যাটর (33000) 33.0 কে হিসাবে ফেরত দেয়
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;
}এখন n ফরমেটার (33000) = 33 কে
/**
* 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;
}টিএক্স @ কোস মন্তব্য করার জন্য, আমি ম্যাথ.উইন্ড 1010 নির্ভরতা সরিয়েছি।
Math.abs(num) >= decimal।
এই থ্রেডের অনেকগুলি উত্তর ম্যাথ অবজেক্টস, ম্যাপ অবজেক্টস, লুপস, রেজেক্স ইত্যাদি ব্যবহার করে জটিল হয়ে যায় তবে এই পদ্ধতিগুলি কোডটির পাঠযোগ্যতা বা কার্য সম্পাদনকে সত্যিই উন্নত করে না। একটি সরাসরি এগিয়ে যাওয়ার পদ্ধতির সেরা নকশা প্রস্তাব বলে মনে হচ্ছে।
const formatCash = n => {
if (n < 1e3) return n;
if (n >= 1e3) return +(n / 1e3).toFixed(1) + "K";
};
console.log(formatCash(2500));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);
}'-' + formatCash(-1 * number)
Negativeণাত্মক সংখ্যা এবং ".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;
}পরীক্ষার মামলাগুলির সাথে জেএসফিডাল -> https://jsfiddle.net/xyug4nvz/7/
abbreviateNumber(999999) == '1000k'পরিবর্তে '1M'। এটি toFixed()কারণগুলিও গোল করে। কীভাবে এটি ঠিক করবেন তা নিশ্চিত নন, যদিও: /
toFixed()যাইহোক এই সংখ্যাটি গোল করে, আপনি এটি পাঠানোর আগে সেই সংখ্যাটিও গোল করতে পারেন abbreviateNumber(), সুতরাং এটি 1Mপরিবর্তে ফিরে আসে 1000k। কোনও সমাধান নয়, বরং একটি কর্মক্ষেত্র।
const floored = Math.floor(scaled * 10) / 10;
ES2020 নীচে Intl.NumberFormatস্বরলিপি ব্যবহার করে এর জন্য সমর্থন যোগ করে:
console.log(Intl.NumberFormat('en-US', { notation: "compact" , compactDisplay: "short" }).format(987654321));NumberFormat চশমা:
মনে রাখবেন যে এই মুহুর্তে সমস্ত ব্রাউজারগুলি ES2020 সমর্থন করে না, সুতরাং আপনার এই পলিফিলের প্রয়োজন হতে পারে: https://formatjs.io/docs/polyfills/intl-number formatt
notationএবং compactDisplayফায়ারফক্স 77 এবং সাফারি 13.1 সমর্থন করে তবে এটি এখনও সমর্থন করে না যাতে আপনার সম্ভবত পলিফিলের প্রয়োজন হবে।
এটি বেশ মার্জিত।
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"পাইথন অ্যাডভান্সড স্ট্রিং ফর্ম্যাটিং পিইপি 3101 এর পরে মডেল করা ডি 3 -ফর্ম্যাট প্যাকেজটি আপনি ব্যবহার করতে পারেন :
var f = require('d3-format')
console.log(f.format('.2s')(2500)) // displays "2.5k"নেতিবাচক সংখ্যা সমর্থন সহ @ যশ এর উত্তর আরও উন্নতি:
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"এই পোস্টটি বেশ পুরানো তবে আমি কিছুটা অনুসন্ধান করে এই পোস্টে পৌঁছেছি। আমার ইনপুট সংখ্যার জেএস যোগ করার জন্য এখন একদিনের স্টপ সমাধান। সংখ্যার ফর্ম্যাট করতে সহায়তা করার জন্য এটি প্রচুর পদ্ধতি দেয়
আপনি যে 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.0 কে-এর পরিবর্তে 1000 কে 1k দেবে
function kFormatter(num) {
return num > 999 ? num % 1000 === 0 ? (num/1000).toFixed(0) + 'k' : (num/1000).toFixed(1) + 'k' : num
}নেতিবাচক উদ্বেগকারীদের সমর্থন সহ ওয়েলন ফ্লিনের উত্তরের একটি পরিবর্তিত সংস্করণ:
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 }!Number.isFinite' K M G T P E Z Y'করার জন্য ' K M'যদি আপনি চান সর্বোচ্চ এককMকোডের নীচে 1K = 1024, আপনি যদি 1 কে = 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দশমিক জায়গাগুলি ফর্ম্যাট করার জন্য আরও @ টিফমন্টীগের উত্তরকে উন্নত করা। 33.0 কে থেকে 33 কে
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;
}পোস্ট করা সমাধানগুলির মধ্যে কোনওটি সন্তুষ্ট নয়, তাই আমার সংস্করণটি এখানে:
একটি নির্ভুলতা পরামিতি সমর্থন করে
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]) );
}আমি একটি খুব কোড গল্ফযুক্ত একটি নিয়ে এসেছি, এবং এটি খুব সংক্ষিপ্ত!
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))1000K ফেরত আসা এনফোর্মিটার (999999,1) এর মতো মামলার কারণে সালমানের জবাব আরও উন্নত করা হবে।
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;
}এটি করার সহজ এবং সহজ উপায় হ'ল
new Intl.NumberFormat('en-IN', {
notation: "compact",
compactDisplay: "short",
style: 'currency',
currency: 'INR'
}).format(1000).replace("T", "K")এটি যে কোনও সংখ্যার জন্য কাজ করে। L Crইত্যাদি সহ
@ মার্টিন-স্জনাপকা দ্রবণে লুপটি সরিয়ে দিয়ে আপনি কার্যকর করার সময় 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 /*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;
}এই ফাংশনটি বিশাল সংখ্যক (ধনাত্মক ও নেতিবাচক) উভয়কে যথার্থতা না হারিয়ে পাঠক বান্ধব বিন্যাসে রূপান্তর করতে পারে:
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);আমি এই ফাংশন ব্যবহার করছি। এটি উভয় 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;
}আমার প্রয়োজন মেটাতে আমি এখানে @ নভেলিজেটরের উত্তরে অনেক প্রসারিত করার সিদ্ধান্ত নিয়েছি। আমি বাহ্যিক লাইব্রেরি ছাড়াই আমার বেশিরভাগ ফর্ম্যাটিংয়ের প্রয়োজনগুলি পরিচালনা করতে নমনীয় ফাংশন চেয়েছিলাম।
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 === '%' ? '%' : '');
}বাহ এখানে অনেক উত্তর আছে। আমি ভেবেছিলাম যে আমি এটি কীভাবে সমাধান করেছি তা এটি পড়ার পক্ষে সবচেয়ে সহজ বলে মনে হচ্ছে, নেতিবাচক সংখ্যাগুলি পরিচালনা করে এবং জাভাস্ক্রিপ্টের জন্য কিলো নম্বর সীমার বাইরে চলে যায়। আপনি যা চান তাতে পরিবর্তন করা এমনকি আরও দূরে প্রসারিত করা সহজ হবে।
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)}`);
}একটি সংক্ষিপ্ত বিকল্প:
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;
}
MএবংG?