एक विशेष लघुता आवश्यकता के साथ जावास्क्रिप्ट में संक्षिप्त संख्या में लंबी संख्या को परिवर्तित करें

Question 1

जावास्क्रिप्ट में, कोई ऐसा फ़ंक्शन कैसे लिखेगा जो किसी दिए गए [संपादित करें: सकारात्मक पूर्णांक ] संख्या (100 बिलियन से नीचे) को 3-अक्षर के संक्षिप्त नाम में परिवर्तित करता है - जहां 0-9 और az / AZ एक पत्र के रूप में गिने जा रहे हैं, लेकिन डॉट (क्योंकि यह कई आनुपातिक फोंट में इतना छोटा है) और अक्षर सीमा के संदर्भ में इसे अनदेखा नहीं किया जाएगा?

यह प्रश्न इस सहायक सूत्र से संबंधित है , लेकिन यह समान नहीं है; उदाहरण के लिए, जहाँ वह फ़ंक्शन बदल जाएगा "123456 -> 1.23k" ("123.5k" 5 अक्षर हैं) मैं कुछ ऐसा खोज रहा हूँ जो "123456 -> 0.1m" ("0 [।] 1m" 3 अक्षर हो। ) है। उदाहरण के लिए, यह आशा कार्य (आउटपुट मूल, सही आदर्श वापसी मान) का आउटपुट होगा:

0                      "0"
12                    "12"
123                  "123"
1234                "1.2k"
12345                "12k"
123456              "0.1m"
1234567             "1.2m"
12345678             "12m"
123456789           "0.1b"
1234567899          "1.2b"
12345678999          "12b"

धन्यवाद!

अपडेट: धन्यवाद! निम्नलिखित संशोधन किए जाने पर आवश्यकताओं के अनुसार एक उत्तर है और काम करता है:

function abbreviateNumber(value) {
    var newValue = value;
    if (value >= 1000) {
        var suffixes = ["", "k", "m", "b","t"];
        var suffixNum = Math.floor( (""+value).length/3 );
        var shortValue = '';
        for (var precision = 2; precision >= 1; precision--) {
            shortValue = parseFloat( (suffixNum != 0 ? (value / Math.pow(1000,suffixNum) ) : value).toPrecision(precision));
            var dotLessShortValue = (shortValue + '').replace(/[^a-zA-Z 0-9]+/g,'');
            if (dotLessShortValue.length <= 2) { break; }
        }
        if (shortValue % 1 != 0)  shortValue = shortValue.toFixed(1);
        newValue = shortValue+suffixes[suffixNum];
    }
    return newValue;
}

Question 2

मेरा मानना है कि Ninjagecko का समाधान उस मानक के अनुरूप नहीं है जो आप चाहते थे। निम्नलिखित कार्य करता है:

function intToString (value) {
    var suffixes = ["", "k", "m", "b","t"];
    var suffixNum = Math.floor((""+value).length/3);
    var shortValue = parseFloat((suffixNum != 0 ? (value / Math.pow(1000,suffixNum)) : value).toPrecision(2));
    if (shortValue % 1 != 0) {
        shortValue = shortValue.toFixed(1);
    }
    return shortValue+suffixes[suffixNum];
}

99 ट्रिलियन से अधिक के मानों के लिए कोई पत्र नहीं जोड़ा जाएगा, जिसे आसानी से 'प्रत्ययों' के सरणी में जोड़कर तय किया जा सकता है।

फिलीपींस द्वारा संपादित निम्नानुसार है: निम्नलिखित परिवर्तनों के साथ यह पूरी तरह से सभी आवश्यकताओं के साथ फिट बैठता है!

function abbreviateNumber(value) {
    var newValue = value;
    if (value >= 1000) {
        var suffixes = ["", "k", "m", "b","t"];
        var suffixNum = Math.floor( (""+value).length/3 );
        var shortValue = '';
        for (var precision = 2; precision >= 1; precision--) {
            shortValue = parseFloat( (suffixNum != 0 ? (value / Math.pow(1000,suffixNum) ) : value).toPrecision(precision));
            var dotLessShortValue = (shortValue + '').replace(/[^a-zA-Z 0-9]+/g,'');
            if (dotLessShortValue.length <= 2) { break; }
        }
        if (shortValue % 1 != 0)  shortValue = shortValue.toFixed(1);
        newValue = shortValue+suffixes[suffixNum];
    }
    return newValue;
}

Question 3

यह बहुत बड़े मूल्यों को भी संभालता है और थोड़ा अधिक सक्सेफुल और कुशल है।

abbreviate_number = function(num, fixed) {
  if (num === null) { return null; } // terminate early
  if (num === 0) { return '0'; } // terminate early
  fixed = (!fixed || fixed < 0) ? 0 : fixed; // number of decimal places to show
  var b = (num).toPrecision(2).split("e"), // get power
      k = b.length === 1 ? 0 : Math.floor(Math.min(b[1].slice(1), 14) / 3), // floor at decimals, ceiling at trillions
      c = k < 1 ? num.toFixed(0 + fixed) : (num / Math.pow(10, k * 3) ).toFixed(1 + fixed), // divide by power
      d = c < 0 ? c : Math.abs(c), // enforce -0 is 0
      e = d + ['', 'K', 'M', 'B', 'T'][k]; // append power
  return e;
}

परिणाम:

for(var a='', i=0; i < 14; i++){ 
    a += i; 
    console.log(a, abbreviate_number(parseInt(a),0)); 
    console.log(-a, abbreviate_number(parseInt(-a),0)); 
}

0 0
-0 0
01 1
-1 -1
012 12
-12 -12
0123 123
-123 -123
01234 1.2K
-1234 -1.2K
012345 12.3K
-12345 -12.3K
0123456 123.5K
-123456 -123.5K
01234567 1.2M
-1234567 -1.2M
012345678 12.3M
-12345678 -12.3M
0123456789 123.5M
-123456789 -123.5M
012345678910 12.3B
-12345678910 -12.3B
01234567891011 1.2T
-1234567891011 -1.2T
0123456789101112 123.5T
-123456789101112 -123.5T
012345678910111213 12345.7T
-12345678910111212 -12345.7T

Question 4

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

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

स्निपेट का विस्तार करें

Question 5

यहाँ मुझे लगता है कि एक काफी सुरुचिपूर्ण समाधान है। यह नकारात्मक संख्या से निपटने का प्रयास नहीं करता है :

const COUNT_ABBRS = [ '', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' ];

function formatCount(count, withAbbr = false, decimals = 2) {
    const i     = 0 === count ? count : Math.floor(Math.log(count) / Math.log(1000));
    let result  = parseFloat((count / Math.pow(1000, i)).toFixed(decimals));
    if(withAbbr) {
        result += `${COUNT_ABBRS[i]}`; 
    }
    return result;
}

उदाहरण :

   formatCount(1000, true);
=> '1k'
   formatCount(100, true);
=> '100'
   formatCount(10000, true);
=> '10k'
   formatCount(10241, true);
=> '10.24k'
   formatCount(10241, true, 0);
=> '10k'
   formatCount(10241, true, 1)
=> '10.2k'
   formatCount(1024111, true, 1)
=> '1M'
   formatCount(1024111, true, 2)
=> '1.02M'

Question 6

मुझे लगता है कि आप इस अंक को नहीं काट सकते /

यदि आप 1000 से 1k में परिवर्तित करना चाहते हैं

console.log(numeral(1000).format('0a'));

और अगर आप 123400 को 123.4k में बदलना चाहते हैं, तो यह कोशिश करें

console.log(numeral(123400).format('0.0a'));

Question 7

आधुनिक, आसान, अंतर्निहित, अत्यधिक अनुकूलन योग्य और 'नो-कोड' तरीका: Intl.FormatNumber का प्रारूप फ़ंक्शन ( संगतता ग्राफ़ )

var numbers = [98721, 9812730,37462,29,093484620123, 9732,0283737718234712]
for(let num of numbers){
  console.log(new Intl.NumberFormat( 'en-US', { maximumFractionDigits: 1,notation: "compact" , compactDisplay: "short" }).format(num));
}
98.7K
9.8M
37.5K
29
93.5B
9.7K
283.7T

टिप्पणियाँ:

यदि आप टाइपस्क्रिप्ट का उपयोग कर रहे हैं तो //@ts-ignoreपहले notation( स्रोत ) जोड़ें
और optionsपैरामीटर में सभी कुंजियों की एक सूची : https://docs.w3cub.com/javascript/global_objects/numberformat/
उपयोग करते समय style: 'currency', आपको अधिकतम निष्कर्षणडाइट को निकालना होगा, क्योंकि यह आपके लिए यह पता लगाएगा।

Question 8

Https://stackoverflow.com/a/10600491/711085 पर मेरे जवाब के आधार पर , आपका उत्तर वास्तव में लागू करने के लिए थोड़ा कम है, इसके द्वारा .substring(0,3):

function format(n) {
    with (Math) {
        var base = floor(log(abs(n))/log(1000));
        var suffix = 'kmb'[base-1];
        return suffix ? String(n/pow(1000,base)).substring(0,3)+suffix : ''+n;
    }
}

(हमेशा की तरह, गणित का उपयोग न करें जब तक कि आपको पता नहीं है कि आप वास्तव में क्या कर रहे हैं; असाइन करने var pow=...और इस तरह से पागल कीड़े का कारण होगा। ऐसा करने के लिए सुरक्षित तरीके के लिए लिंक देखें।)

> tests = [-1001, -1, 0, 1, 2.5, 999, 1234, 
           1234.5, 1000001, Math.pow(10,9), Math.pow(10,12)]
> tests.forEach(function(x){ console.log(x,format(x)) })

-1001 "-1.k"
-1 "-1"
0 "0"
1 "1"
2.5 "2.5"
999 "999"
1234 "1.2k"
1234.5 "1.2k"
1000001 "1.0m"
1000000000 "1b"
1000000000000 "1000000000000"

आपको उस मामले को पकड़ने की आवश्यकता होगी जहां परिणाम> = 1 ट्रिलियन है, यदि आपकी आवश्यकता 3 चार्ट के लिए सख्त है, तो आप भ्रष्ट डेटा बनाने का जोखिम उठाते हैं, जो बहुत बुरा होगा।

Question 9

कोड

const SI_PREFIXES = [
  { 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' },
]

const abbreviateNumber = (number) => {
  if (number === 0) return number

  const tier = SI_PREFIXES.filter((n) => number >= n.value).pop()
  const numberFixed = (number / tier.value).toFixed(1)

  return `${numberFixed}${tier.symbol}`
}

abbreviateNumber(2000) // "2.0k"
abbreviateNumber(2500) // "2.5k"
abbreviateNumber(255555555) // "255.6M"

परीक्षा:

import abbreviateNumber from './abbreviate-number'

test('abbreviateNumber', () => {
  expect(abbreviateNumber(0)).toBe('0')
  expect(abbreviateNumber(100)).toBe('100')
  expect(abbreviateNumber(999)).toBe('999')

  expect(abbreviateNumber(1000)).toBe('1.0k')
  expect(abbreviateNumber(100000)).toBe('100.0k')
  expect(abbreviateNumber(1000000)).toBe('1.0M')
  expect(abbreviateNumber(1e6)).toBe('1.0M')
  expect(abbreviateNumber(1e10)).toBe('10.0G')
  expect(abbreviateNumber(1e13)).toBe('10.0T')
  expect(abbreviateNumber(1e16)).toBe('10.0P')
  expect(abbreviateNumber(1e19)).toBe('10.0E')

  expect(abbreviateNumber(1500)).toBe('1.5k')
  expect(abbreviateNumber(1555)).toBe('1.6k')

  expect(abbreviateNumber(undefined)).toBe('0')
  expect(abbreviateNumber(null)).toBe(null)
  expect(abbreviateNumber('100')).toBe('100')
  expect(abbreviateNumber('1000')).toBe('1.0k')
})

Question 10

यहाँ एक और ले रहा है। मैं चाहता था कि 0.145 के बजाय 123456 123.4K हो

function convert(value) {

    var length = (value + '').length,
        index = Math.ceil((length - 3) / 3),
        suffix = ['K', 'M', 'G', 'T'];

    if (length < 4) return value;
    
    return (value / Math.pow(1000, index))
           .toFixed(1)
           .replace(/\.0$/, '') + suffix[index - 1];

}

var tests = [1234, 7890, 123456, 567890, 800001, 2000000, 20000000, 201234567, 801234567, 1201234567];
for (var i in tests)
    document.writeln('<p>convert(' + tests[i] + ') = ' + convert(tests[i]) + '</p>');

स्निपेट का विस्तार करें

Question 11

कुछ के आसपास खेलने के बाद, यह दृष्टिकोण आवश्यक मानदंडों को पूरा करता है। @ Chuckator के उत्तर से कुछ प्रेरणा लेता है।

function abbreviateNumber(value) {

    if (value <= 1000) {
        return value.toString();
    }

    const numDigits = (""+value).length;
    const suffixIndex = Math.floor(numDigits / 3);

    const normalisedValue = value / Math.pow(1000, suffixIndex);

    let precision = 2;
    if (normalisedValue < 1) {
        precision = 1;
    }

    const suffixes = ["", "k", "m", "b","t"];
    return normalisedValue.toPrecision(precision) + suffixes[suffixIndex];
}

Question 12

मैं इन मूल्यों को प्राप्त करने के लिए इस फ़ंक्शन का उपयोग कर रहा हूं।

function Converter(number, fraction) {
    let ranges = [
      { divider: 1, suffix: '' },
      { divider: 1e3, suffix: 'K' },
      { divider: 1e6, suffix: 'M' },
      { divider: 1e9, suffix: 'G' },
      { divider: 1e12, suffix: 'T' },
      { divider: 1e15, suffix: 'P' },
      { divider: 1e18, suffix: 'E' },
    ]
    //find index based on number of zeros
    let index = (Math.abs(number).toString().length / 3).toFixed(0)
    return (number / ranges[index].divider).toFixed(fraction) + ranges[index].suffix
}

प्रत्येक 3 अंक में अलग-अलग प्रत्यय होते हैं, यही मैं सबसे पहले खोजने की कोशिश कर रहा हूं।

इसलिए, यदि मौजूद है तो ऋणात्मक चिन्ह हटा दें , फिर इस संख्या में कितने 3 अंक हैं।

उसके बाद पिछली संख्या के आधार पर उपयुक्त प्रत्यय को विभाजित संख्या में जोड़ा गया।

Converter(1500, 1)

वापस होगा:

1.5K

Question 13

Intl कार्यान्वित अंतर्राष्ट्रीय व्यवहारों के लिए जावास्क्रिप्ट मानक 'पैकेज' है। Intl.NumberFormatter विशेष रूप से स्थानीयकृत संख्या फ़ॉर्मेटर है। तो यह कोड वास्तव में आपके स्थानीय रूप से कॉन्फ़िगर किए गए हजारों और दशमलव विभाजकों का सम्मान करता है।

intlFormat(num) {
    return new Intl.NumberFormat().format(Math.round(num*10)/10);
}

abbreviateNumber(value) {
    let num = Math.floor(value);
    if(num >= 1000000000)
        return this.intlFormat(num/1000000000)+'B';
    if(num >= 1000000)
        return this.intlFormat(num/1000000)+'M';
    if(num >= 1000)
        return this.intlFormat(num/1000)+'k';
    return this.intlFormat(num);
}

संक्षिप्त नाम (999999999999) // 999B देता है

संबंधित प्रश्न: हजारों (1k) और लाखों (1m) के लिए जावास्क्रिप्ट में एक स्थानीय संख्या संक्षिप्त करें

Question 14

            function converse_number (labelValue) {

                    // Nine Zeroes for Billions
                    return Math.abs(Number(labelValue)) >= 1.0e+9

                    ? Math.abs(Number(labelValue)) / 1.0e+9 + "B"
                    // Six Zeroes for Millions 
                    : Math.abs(Number(labelValue)) >= 1.0e+6

                    ? Math.abs(Number(labelValue)) / 1.0e+6 + "M"
                    // Three Zeroes for Thousands
                    : Math.abs(Number(labelValue)) >= 1.0e+3

                    ? Math.abs(Number(labelValue)) / 1.0e+3 + "K"

                    : Math.abs(Number(labelValue));

                }

चेतावनी (converse_number (100000000000));

Question 15

@ निमेशाराम

आपका समाधान निम्नलिखित मामले के लिए वांछनीय नहीं होगा:

Input 50000
Output 50.0k

निम्नलिखित समाधान ठीक काम करेगा।

const convertNumberToShortString = (
  number: number,
  fraction: number
) => {
  let newValue: string = number.toString();
  if (number >= 1000) {
    const ranges = [
      { divider: 1, suffix: '' },
      { divider: 1e3, suffix: 'k' },
      { divider: 1e6, suffix: 'm' },
      { divider: 1e9, suffix: 'b' },
      { divider: 1e12, suffix: 't' },
      { divider: 1e15, suffix: 'p' },
      { divider: 1e18, suffix: 'e' }
    ];
    //find index based on number of zeros
    const index = Math.floor(Math.abs(number).toString().length / 3);
    let numString = (number / ranges[index].divider).toFixed(fraction);
    numString =
      parseInt(numString.substring(numString.indexOf('.') + 1)) === 0
        ? Math.floor(number / ranges[index].divider).toString()
        : numString;
    newValue = numString + ranges[index].suffix;
  }
  return newValue;
};

// Input 50000
// Output 50k
// Input 4500
// Output 4.5k

Question 16

एक नंबर प्रोटोटाइप के रूप में उपयोग करें

आसान और सीधा आपके लिए। बस इसका एक प्रोटोटाइप बनाएं। यहाँ एक उदाहरण है।

Number.prototype.abbr = function (decimal = 2): string {
  const notations = ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'],
    i = Math.floor(Math.log(this) / Math.log(1000));
  return `${parseFloat((this / Math.pow(1000, i)).toFixed(decimal))}${notations[i]}`;
};

Question 17

भारतीय मुद्रा का प्रारूप (K, L, C) हजार, लाख, करोड़

const formatCash = n => {
  if (n < 1e3) return n;
  if (n >= 1e3 && n < 1e5) return +(n / 1e3).toFixed(1) + "K";
  if (n >= 1e5 && n <= 1e6) return +(n / 1e5).toFixed(1) + "L";
  if (n >= 1e6 && n <= 1e9) return +(n / 1e7).toFixed(1) + "C";
};