javascript - today - सिंगापुर डॉलर इंडियन रुपीस




मैं जावास्क्रिप्ट में डॉलर मुद्रा स्ट्रिंग के रूप में संख्याओं को कैसे प्रारूपित कर सकता हूं? (20)

Intl.numberformat

जावास्क्रिप्ट में एक नंबर फॉर्मेटर (अंतर्राष्ट्रीयकरण एपीआई का हिस्सा) है।

// Create our number formatter.
var formatter = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
});

formatter.format(2500); /* $2,500.00 */

जेएस की बेला

सिस्टम लोकेल का उपयोग करने के लिए पहले तर्क (उदाहरण में 'en-US' ) के स्थान पर undefined का उपयोग करें (यदि किसी ब्राउज़र में कोड चल रहा हो तो उपयोगकर्ता का स्थान)।

Intl.NumberFormat बनाम Number.prototyp.toLocaleString

एक पुराने नोट की तुलना पुराने से की जा रही है। toLocaleString । वे दोनों अनिवार्य रूप से समान कार्यक्षमता प्रदान करते हैं। हालाँकि, अपने पुराने अवतारों में (to-intl) toLocaleString वास्तव में स्थानों का समर्थन नहीं करता है : यह सिस्टम लोकेल का उपयोग करता है। इसलिए, सुनिश्चित करें कि आप सही संस्करण का उपयोग कर रहे हैं ( एमडीएन Intl के अस्तित्व की जांच करने का सुझाव देता है )। साथ ही, एकल आइटम के लिए दोनों का प्रदर्शन समान है, लेकिन यदि आपके पास Intl.NumberFormat का उपयोग करके प्रारूप करने के लिए बहुत अधिक संख्या है, तो ~ 70 गुना तेज है। यहाँ कैसे toLocaleString का उपयोग करने के लिए है:

(2500).toLocaleString('en-US', {
  style: 'currency',
  currency: 'USD',
}); /* $2,500.00 */

ब्राउज़र समर्थन पर कुछ नोट्स

  • US / EU में 97% समर्थन के साथ ब्राउज़र समर्थन अब कोई समस्या नहीं है
  • दुनिया के अन्य हिस्सों (90% समर्थित) के लिए, समर्थन के मामले में सबसे बड़े अपराधी यूसी मोबाइल ( उस से दूर रहें ) और ओपेरा मिनी (डिजाइन द्वारा अपंग) हैं
  • पुराने ब्राउज़रों पर इसका समर्थन करने के लिए एक shim है
  • अधिक जानकारी के लिए CanIUse पर एक नज़र डालें

मैं जावास्क्रिप्ट में एक मूल्य प्रारूप करना चाहूंगा।
मुझे एक फंक्शन चाहिए जो एक तर्क के रूप में एक float लेता है और एक string को इस तरह स्वरूपित करता है:

"$ 2,500.00"

ऐसा करने का सबसे अच्छा तरीका क्या है?


लघु और तेज समाधान (हर जगह काम करता है!)

(12345.67).toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');  // 12,345.67

इस समाधान के पीछे विचार मिलान वाले खंडों को पहले मैच और अल्पविराम की जगह दे रहा है, अर्थात '$&,' । मिलान लुकहेड दृष्टिकोण का उपयोग करके किया जाता है। यदि आप तीन नंबर सेट (एक या अधिक) और एक डॉट के अनुक्रम के बाद "संख्या से मेल खाते हैं तो अभिव्यक्ति को पढ़ सकते हैं। "

परीक्षण:

1        --> "1.00"
12       --> "12.00"
123      --> "123.00"
1234     --> "1,234.00"
12345    --> "12,345.00"
123456   --> "123,456.00"
1234567  --> "1,234,567.00"
12345.67 --> "12,345.67"

डेमो: http://jsfiddle.net/hAfMM/9571/

विस्तारित लघु समाधान

आप किसी भी संख्या के दशमलव के अतिरिक्त समर्थन को जोड़ने के लिए Number ऑब्जेक्ट के प्रोटोटाइप का विस्तार कर सकते हैं [0 .. n] और संख्या समूहों का आकार [0 .. x] :

/**
 * Number.prototype.format(n, x)
 * 
 * @param integer n: length of decimal
 * @param integer x: length of sections
 */
Number.prototype.format = function(n, x) {
    var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\.' : '$') + ')';
    return this.toFixed(Math.max(0, ~~n)).replace(new RegExp(re, 'g'), '$&,');
};

1234..format();           // "1,234"
12345..format(2);         // "12,345.00"
123456.7.format(3, 2);    // "12,34,56.700"
123456.789.format(2, 4);  // "12,3456.79"

DEMO / TESTS: http://jsfiddle.net/hAfMM/435/

सुपर विस्तारित लघु समाधान

इस सुपर विस्तारित संस्करण में आप विभिन्न सीमांकक प्रकार सेट कर सकते हैं:

/**
 * Number.prototype.format(n, x, s, c)
 * 
 * @param integer n: length of decimal
 * @param integer x: length of whole part
 * @param mixed   s: sections delimiter
 * @param mixed   c: decimal delimiter
 */
Number.prototype.format = function(n, x, s, c) {
    var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\D' : '$') + ')',
        num = this.toFixed(Math.max(0, ~~n));

    return (c ? num.replace('.', c) : num).replace(new RegExp(re, 'g'), '$&' + (s || ','));
};

12345678.9.format(2, 3, '.', ',');  // "12.345.678,90"
123456.789.format(4, 4, ' ', ':');  // "12 3456:7890"
12345678.9.format(0, 3, '-');       // "12-345-679"

DEMO / TESTS: http://jsfiddle.net/hAfMM/612/


PHP फ़ंक्शन "number_format" का एक जावास्क्रिप्ट पोर्ट है।

मुझे यह बहुत उपयोगी लगता है क्योंकि यह PHP डेवलपर्स के लिए उपयोग करने और पहचानने में आसान है।

function number_format (number, decimals, dec_point, thousands_sep) {
    var n = number, prec = decimals;

    var toFixedFix = function (n,prec) {
        var k = Math.pow(10,prec);
        return (Math.round(n*k)/k).toString();
    };

    n = !isFinite(+n) ? 0 : +n;
    prec = !isFinite(+prec) ? 0 : Math.abs(prec);
    var sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep;
    var dec = (typeof dec_point === 'undefined') ? '.' : dec_point;

    var s = (prec > 0) ? toFixedFix(n, prec) : toFixedFix(Math.round(n), prec); 
    //fix for IE parseFloat(0.55).toFixed(0) = 0;

    var abs = toFixedFix(Math.abs(n), prec);
    var _, i;

    if (abs >= 1000) {
        _ = abs.split(/\D/);
        i = _[0].length % 3 || 3;

        _[0] = s.slice(0,i + (n < 0)) +
               _[0].slice(i).replace(/(\d{3})/g, sep+'$1');
        s = _.join(dec);
    } else {
        s = s.replace('.', dec);
    }

    var decPos = s.indexOf(dec);
    if (prec >= 1 && decPos !== -1 && (s.length-decPos-1) < prec) {
        s += new Array(prec-(s.length-decPos-1)).join(0)+'0';
    }
    else if (prec >= 1 && decPos === -1) {
        s += dec+new Array(prec).join(0)+'0';
    }
    return s; 
}

( मूल से टिप्पणी ब्लॉक, उदाहरण और क्रेडिट के लिए नीचे शामिल है जहां देय)

// Formats a number with grouped thousands
//
// version: 906.1806
// discuss at: http://phpjs.org/functions/number_format
// +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
// +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
// +     bugfix by: Michael White (http://getsprink.com)
// +     bugfix by: Benjamin Lupton
// +     bugfix by: Allan Jensen (http://www.winternet.no)
// +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
// +     bugfix by: Howard Yeend
// +    revised by: Luke Smith (http://lucassmith.name)
// +     bugfix by: Diogo Resende
// +     bugfix by: Rival
// +     input by: Kheang Hok Chin (http://www.distantia.ca/)
// +     improved by: davook
// +     improved by: Brett Zamir (http://brett-zamir.me)
// +     input by: Jay Klehr
// +     improved by: Brett Zamir (http://brett-zamir.me)
// +     input by: Amir Habibi (http://www.residence-mixte.com/)
// +     bugfix by: Brett Zamir (http://brett-zamir.me)
// *     example 1: number_format(1234.56);
// *     returns 1: '1,235'
// *     example 2: number_format(1234.56, 2, ',', ' ');
// *     returns 2: '1 234,56'
// *     example 3: number_format(1234.5678, 2, '.', '');
// *     returns 3: '1234.57'
// *     example 4: number_format(67, 2, ',', '.');
// *     returns 4: '67,00'
// *     example 5: number_format(1000);
// *     returns 5: '1,000'
// *     example 6: number_format(67.311, 2);
// *     returns 6: '67.31'
// *     example 7: number_format(1000.55, 1);
// *     returns 7: '1,000.6'
// *     example 8: number_format(67000, 5, ',', '.');
// *     returns 8: '67.000,00000'
// *     example 9: number_format(0.9, 0);
// *     returns 9: '1'
// *     example 10: number_format('1.20', 2);
// *     returns 10: '1.20'
// *     example 11: number_format('1.20', 4);
// *     returns 11: '1.2000'
// *     example 12: number_format('1.2000', 3);
// *     returns 12: '1.200'

जावास्क्रिप्ट Number ऑब्जेक्ट पर एक नज़र डालें और देखें कि क्या यह आपकी मदद कर सकता है।

  • toLocaleString() स्थान विशिष्ट हजारों विभाजक का उपयोग करके संख्या को प्रारूपित करेगा।
  • toFixed() दशमलव स्थानों की एक विशिष्ट संख्या के लिए संख्या को गोल करेगा।

एक ही समय में इनका उपयोग करने के लिए मूल्य का प्रकार एक संख्या में वापस बदल जाना चाहिए क्योंकि वे दोनों एक स्ट्रिंग का उत्पादन करते हैं।

उदाहरण:

Number(someNumber.toFixed(1)).toLocaleString()

तो किसी ने निम्नलिखित का सुझाव क्यों नहीं दिया?

(2500).toLocaleString("en-GB", {style: "currency", currency: "GBP", minimumFractionDigits: 2}) 

अधिकांश / कुछ ब्राउज़रों के लिए काम करता है:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…


नीचे कुछ टिप्पणियों और कुछ छोटे बदलावों के साथ पैट्रिक डेसजार्डिन्स (उर्फ डॉक) कोड दिया गया है:

/* 
decimal_sep: character used as deciaml separtor, it defaults to '.' when omitted
thousands_sep: char used as thousands separator, it defaults to ',' when omitted
*/
Number.prototype.toMoney = function(decimals, decimal_sep, thousands_sep)
{ 
   var n = this,
   c = isNaN(decimals) ? 2 : Math.abs(decimals), //if decimal is zero we must take it, it means user does not want to show any decimal
   d = decimal_sep || '.', //if no decimal separator is passed we use the dot as default decimal separator (we MUST use a decimal separator)

   /*
   according to [https://.com/questions/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function]
   the fastest way to check for not defined parameter is to use typeof value === 'undefined' 
   rather than doing value === undefined.
   */   
   t = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep, //if you don't want to use a thousands separator you can pass empty string as thousands_sep value

   sign = (n < 0) ? '-' : '',

   //extracting the absolute value of the integer part of the number and converting to string
   i = parseInt(n = Math.abs(n).toFixed(c)) + '', 

   j = ((j = i.length) > 3) ? j % 3 : 0; 
   return sign + (j ? i.substr(0, j) + t : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : ''); 
}

और यहाँ कुछ परीक्षण:

//some tests (do not forget parenthesis when using negative numbers and number with no decimals)
alert(123456789.67392.toMoney() + '\n' + 123456789.67392.toMoney(3) + '\n' + 123456789.67392.toMoney(0) + '\n' + (123456).toMoney() + '\n' + (123456).toMoney(0) + '\n' + 89.67392.toMoney() + '\n' + (89).toMoney());

//some tests (do not forget parenthesis when using negative numbers and number with no decimals)
alert((-123456789.67392).toMoney() + '\n' + (-123456789.67392).toMoney(-3));

मामूली बदलाव हैं:

  1. थोड़ा सा Math.abs(decimals) केवल NaN नहीं होने पर ले जाया गया।

  2. decimal_sep अब स्ट्रिंग नहीं हो सकती (दशमलव विभाजक का कुछ प्रकार एक जरूरी है)

  3. हम typeof thousands_sep === 'undefined' करते हैं typeof thousands_sep === 'undefined' रूप में सुझाव दिया जाता है कि जावास्क्रिप्ट फ़ंक्शन के लिए एक तर्क नहीं भेजा जाता है, तो यह निर्धारित करने के लिए कितना अच्छा है

  4. (+n || 0) की आवश्यकता नहीं है क्योंकि this एक Number वस्तु है

जेएस फिडल


मूल विधि प्रदान करने के लिए जोनाथन एम को +1। चूंकि यह स्पष्ट रूप से एक मुद्रा फ़ॉर्मेटर है, इसलिए मैंने आगे बढ़कर मुद्रा प्रतीक (आउटपुट में '$' के लिए डिफॉल्ट) को जोड़ा, और हजारों विभाजक के रूप में डिफ़ॉल्ट अल्पविराम जोड़ा। यदि आप वास्तव में एक मुद्रा प्रतीक (या हजारों विभाजक) नहीं चाहते हैं, तो इसके लिए अपने तर्क के रूप में बस "" (खाली स्ट्रिंग) का उपयोग करें।

Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator, currencySymbol) {
    // check the args and supply defaults:
    decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;
    decSeparator = decSeparator == undefined ? "." : decSeparator;
    thouSeparator = thouSeparator == undefined ? "," : thouSeparator;
    currencySymbol = currencySymbol == undefined ? "$" : currencySymbol;

    var n = this,
        sign = n < 0 ? "-" : "",
        i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "",
        j = (j = i.length) > 3 ? j % 3 : 0;

    return sign + currencySymbol + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : "");
};

मैं पुस्तकालय का उपयोग करें Globalize (Microsoft से):

यह संख्याओं, मुद्राओं और तारीखों को स्थानीय बनाने और उपयोगकर्ता लोकेल के अनुसार सही तरीके से स्वरूपित करने के लिए एक बेहतरीन परियोजना है! ... और इसके बावजूद यह एक jQuery एक्सटेंशन होना चाहिए, यह वर्तमान में एक 100% स्वतंत्र पुस्तकालय है। मैं आप सभी को इसे आजमाने का सुझाव देता हूँ! :)


यहाँ मैंने देखा है सबसे अच्छा जेएस मनी फॉर्मैटर है:

Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator) {
    var n = this,
        decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,
        decSeparator = decSeparator == undefined ? "." : decSeparator,
        thouSeparator = thouSeparator == undefined ? "," : thouSeparator,
        sign = n < 0 ? "-" : "",
        i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "",
        j = (j = i.length) > 3 ? j % 3 : 0;
    return sign + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : "");
};

इसे यहाँ से पुनः स्वरूपित और उधार लिया गया था: https://.com/a/149099/751484

आपको अपने स्वयं के मुद्रा पदनाम (आप $ ऊपर इस्तेमाल किया गया) की आपूर्ति करनी होगी।

इसे इस तरह से कॉल करें (हालांकि ध्यान दें कि आर्ग्स डिफ़ॉल्ट रूप से 2, अल्पविराम, और अवधि के लिए है, इसलिए आपको अपनी पसंद के अनुसार किसी भी आर्ग्स की आपूर्ति करने की आवश्यकता नहीं है):

var myMoney=3543.75873;
var formattedMoney = '$' + myMoney.formatMoney(2,',','.'); // "$3,543.76"

यहां पहले से ही कुछ शानदार जवाब हैं। यहाँ एक और प्रयास है, सिर्फ मनोरंजन के लिए:

function formatDollar(num) {
    var p = num.toFixed(2).split(".");
    return "$" + p[0].split("").reverse().reduce(function(acc, num, i, orig) {
        return  num=="-" ? acc : num + (i && !(i % 3) ? "," : "") + acc;
    }, "") + "." + p[1];
}

और कुछ परीक्षण:

formatDollar(45664544.23423) // "$45,664,544.23"
formatDollar(45) // "$45.00"
formatDollar(123) // "$123.00"
formatDollar(7824) // "$7,824.00"
formatDollar(1) // "$1.00"

संपादित: अब यह नकारात्मक संख्या को भी संभालेगा


accounting.js संख्या, धन और मुद्रा प्रारूपण के लिए एक छोटा जावास्क्रिप्ट पुस्तकालय है।


javascript-number-formatter (पूर्व में Google कोड में )

  • लघु, तेज, लचीला अभी तक स्टैंडअलोन। केवल 75 लाइनें जिनमें MIT लाइसेंस जानकारी, रिक्त लाइनें और टिप्पणियां शामिल हैं।
  • मानक संख्या स्वरूपण जैसे #,##0.00 या नकार -000.#### साथ -000.####
  • किसी भी देश के प्रारूप जैसे # ##0,00 , #,###.## , #'###.## या किसी भी प्रकार का गैर-संख्या चिह्न स्वीकार करें।
  • अंकों के समूहन के किसी भी संख्या को स्वीकार करें। #,##,#0.000 या #,###0.## सभी वैध हैं।
  • किसी भी निरर्थक / मूर्ख-प्रमाण स्वरूपण को स्वीकार करें। ##,###,##.# या 0#,#00#.###0# सभी ठीक हैं।
  • ऑटो नंबर राउंडिंग।
  • सरल इंटरफ़ेस, बस इस तरह मुखौटा और मूल्य की आपूर्ति करें: format( "0.0000", 3.141592)
  • मास्क के साथ एक उपसर्ग और प्रत्यय शामिल करें

(इसके README से अंश)


पैट्रिक डेसजार्डिन्स का जवाब अच्छा लगता है, लेकिन मैं अपनी जावास्क्रिप्ट को सरल पसंद करता हूं। यहाँ एक फ़ंक्शन है जिसे मैंने बस एक संख्या लेने के लिए और इसे मुद्रा प्रारूप में वापस करने के लिए लिखा है (डॉलर चिह्न को घटाकर)

// Format numbers to two decimals with commas
function formatDollar(num) {
    var p = num.toFixed(2).split(".");
    var chars = p[0].split("").reverse();
    var newstr = '';
    var count = 0;
    for (x in chars) {
        count++;
        if(count%3 == 1 && count != 1) {
            newstr = chars[x] + ',' + newstr;
        } else {
            newstr = chars[x] + newstr;
        }
    }
    return newstr + "." + p[1];
}

मुख्य भाग हजार-विभाजकों को सम्मिलित कर रहा है, जो इस तरह किया जा सकता है:

<script type="text/javascript">
function ins1000Sep(val){
  val = val.split(".");
  val[0] = val[0].split("").reverse().join("");
  val[0] = val[0].replace(/(\d{3})/g,"$1,");
  val[0] = val[0].split("").reverse().join("");
  val[0] = val[0].indexOf(",")==0?val[0].substring(1):val[0];
  return val.join(".");
}
function rem1000Sep(val){
  return val.replace(/,/g,"");
}
function formatNum(val){
  val = Math.round(val*100)/100;
  val = (""+val).indexOf(".")>-1 ? val + "00" : val + ".00";
  var dec = val.indexOf(".");
  return dec == val.length-3 || dec == 0 ? val : val.substring(0,dec+3);
}
</script>

<button onclick="alert(ins1000Sep(formatNum(12313231)));">

आमतौर पर, एक ही काम करने के कई तरीके हैं, लेकिन मैं Number.prototype.toLocaleStringइसका उपयोग करने से बचता हूं क्योंकि यह उपयोगकर्ता सेटिंग्स के आधार पर विभिन्न मूल्यों को वापस कर सकता है।

मैं यह भी सलाह नहीं देता हूं Number.prototype- मूल वस्तुओं को विस्तारित करना प्रोटोटाइप एक बुरा अभ्यास है क्योंकि यह अन्य लोगों के कोड (जैसे लाइब्रेरी / फ्रेमवर्क / प्लगइन्स) के साथ संघर्ष का कारण बन सकता है और भविष्य के जावास्क्रिप्ट कार्यान्वयन / संस्करणों के साथ संगत नहीं हो सकता है।

मेरा मानना ​​है कि नियमित अभिव्यक्ति समस्या के लिए सबसे अच्छा तरीका है, यहाँ मेरा कार्यान्वयन है:

/**
 * Converts number into currency format
 * @param {number} number   Number that should be converted.
 * @param {string} [decimalSeparator]    Decimal separator, defaults to '.'.
 * @param {string} [thousandsSeparator]    Thousands separator, defaults to ','.
 * @param {int} [nDecimalDigits]    Number of decimal digits, defaults to `2`.
 * @return {string} Formatted string (e.g. numberToCurrency(12345.67) returns '12,345.67')
 */
function numberToCurrency(number, decimalSeparator, thousandsSeparator, nDecimalDigits){
    //default values
    decimalSeparator = decimalSeparator || '.';
    thousandsSeparator = thousandsSeparator || ',';
    nDecimalDigits = nDecimalDigits == null? 2 : nDecimalDigits;

    var fixed = number.toFixed(nDecimalDigits), //limit/add decimal digits
        parts = new RegExp('^(-?\\d{1,3})((?:\\d{3})+)(\\.(\\d{'+ nDecimalDigits +'}))?$').exec( fixed ); //separate begin [$1], middle [$2] and decimal digits [$4]

    if(parts){ //number >= 1000 || number <= -1000
        return parts[1] + parts[2].replace(/\d{3}/g, thousandsSeparator + '$&') + (parts[4] ? decimalSeparator + parts[4] : '');
    }else{
        return fixed.replace('.', decimalSeparator);
    }
}

2010/08/30 को संपादित: दशमलव अंकों की संख्या निर्धारित करने के लिए जोड़ा गया विकल्प। 2011/08/23 को संपादित: दशमलव अंकों की संख्या को शून्य पर सेट करने का विकल्प जोड़ा गया।


एक अंतर्निहित function toFixed हैjavascript

var num = new Number(349);
document.write("$" + num.toFixed(2));

मुझे यह मिला: accounting.jsaccounting.jsइसकी बहुत आसान और पूरी तरह से मेरी जरूरत है।

// Default usage:
accounting.formatMoney(12345678); // $12,345,678.00

// European formatting (custom symbol and separators), can also use options object as second parameter:
accounting.formatMoney(4999.99, "€", 2, ".", ","); // €4.999,99

// Negative values can be formatted nicely:
accounting.formatMoney(-500000, "£ ", 0); // £ -500,000

// Simple `format` string allows control of symbol position (%v = value, %s = symbol):
accounting.formatMoney(5318008, { symbol: "GBP",  format: "%v %s" }); // 5,318,008.00 GBP

// Euro currency symbol to the right
accounting.formatMoney(5318008, {symbol: "€", precision: 2, thousand: ".", decimal : ",", format: "%v%s"}); // 1.008,00€ 


मैं Google विज़ुअलाइज़ेशन एपीआई से नंबरफ़ॉर्मैट क्लास का सुझाव देता हूं ।

आप ऐसा कुछ कर सकते हैं:

var formatter = new google.visualization.NumberFormat({
    prefix: '$',
    pattern: '#,###,###.##'
});

formatter.formatValue(1000000); // $ 1,000,000

मुझे उम्मीद है यह मदद करेगा।


यह थोड़ी देर हो सकती है, लेकिन यहाँ एक विधि है, जिसमें मैंने एक सहकर्मी .toCurrencyString()को सभी नंबरों के लिए स्थानीय-जागरूक फ़ंक्शन जोड़ने के लिए काम किया है । आंतरिककरण केवल संख्या समूह के लिए है, मुद्रा चिह्न नहीं - यदि आप डॉलर का उत्पादन कर रहे हैं, तो "$"आपूर्ति के रूप में उपयोग करें , क्योंकि $123 4567जापान या चीन में यूएसडी की समान संख्या है जैसा $1,234,567कि अमेरिका में है। यदि आप यूरो / इत्यादि का उत्पादन कर रहे हैं, तो मुद्रा चिन्ह को बदल दें "$"

इसे अपने HEAD में या जहाँ भी आवश्यक हो, कहीं भी इस्तेमाल करने से पहले इसे घोषित करें:

  Number.prototype.toCurrencyString = function(prefix, suffix) {
    if (typeof prefix === 'undefined') { prefix = '$'; }
    if (typeof suffix === 'undefined') { suffix = ''; }
    var _localeBug = new RegExp((1).toLocaleString().replace(/^1/, '').replace(/\./, '\\.') + "$");
    return prefix + (~~this).toLocaleString().replace(_localeBug, '') + (this % 1).toFixed(2).toLocaleString().replace(/^[+-]?0+/,'') + suffix;
  }

फिर आप कर रहे हैं! (number).toCurrencyString()मुद्रा के रूप में संख्या को आउटपुट करने के लिए आपको कहीं भी उपयोग करने की आवश्यकता है।

var MyNumber = 123456789.125;
alert(MyNumber.toCurrencyString()); // alerts "$123,456,789.13"
MyNumber = -123.567;
alert(MyNumber.toCurrencyString()); // alerts "$-123.57"

यहां कुछ समाधान दिए गए हैं, सभी टेस्ट सूट, टेस्ट सूट और बेंचमार्क को शामिल करते हैं, यदि आप परीक्षण करने के लिए कॉपी और पेस्ट चाहते हैं, तो इस जिस्ट का प्रयास करें ।

विधि 0 (RegExp)

आधार पर https://.com/a/14428340/1877620 , लेकिन दशमलव बिंदु न होने पर ठीक करें।

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.');
        a[0] = a[0].replace(/\d(?=(\d{3})+$)/g, '$&,');
        return a.join('.');
    }
}

विधि 1

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.'),
            // skip the '-' sign
            head = Number(this < 0);

        // skip the digits that's before the first thousands separator 
        head += (a[0].length - head) % 3 || 3;

        a[0] = a[0].slice(0, head) + a[0].slice(head).replace(/\d{3}/g, ',$&');
        return a.join('.');
    };
}

विधि 2 (ऐरे से विभाजित)

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.');

        a[0] = a[0]
            .split('').reverse().join('')
            .replace(/\d{3}(?=\d)/g, '$&,')
            .split('').reverse().join('');

        return a.join('.');
    };
}

विधि 3 (लूप)

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('');
        a.push('.');

        var i = a.indexOf('.') - 3;
        while (i > 0 && a[i-1] !== '-') {
            a.splice(i, 0, ',');
            i -= 3;
        }

        a.pop();
        return a.join('');
    };
}

उपयोग उदाहरण

console.log('======== Demo ========')
console.log(
    (1234567).format(0),
    (1234.56).format(2),
    (-1234.56).format(0)
);
var n = 0;
for (var i=1; i<20; i++) {
    n = (n * 10) + (i % 10)/100;
    console.log(n.format(2), (-n).format(2));
}

सेपरेटर

यदि हम कस्टम हजारों विभाजक या दशमलव विभाजक चाहते हैं, तो उपयोग करें replace():

123456.78.format(2).replace(',', ' ').replace('.', ' ');

परीक्षण सूट

function assertEqual(a, b) {
    if (a !== b) {
        throw a + ' !== ' + b;
    }
}

function test(format_function) {
    console.log(format_function);
    assertEqual('NaN', format_function.call(NaN, 0))
    assertEqual('Infinity', format_function.call(Infinity, 0))
    assertEqual('-Infinity', format_function.call(-Infinity, 0))

    assertEqual('0', format_function.call(0, 0))
    assertEqual('0.00', format_function.call(0, 2))
    assertEqual('1', format_function.call(1, 0))
    assertEqual('-1', format_function.call(-1, 0))
    // decimal padding
    assertEqual('1.00', format_function.call(1, 2))
    assertEqual('-1.00', format_function.call(-1, 2))
    // decimal rounding
    assertEqual('0.12', format_function.call(0.123456, 2))
    assertEqual('0.1235', format_function.call(0.123456, 4))
    assertEqual('-0.12', format_function.call(-0.123456, 2))
    assertEqual('-0.1235', format_function.call(-0.123456, 4))
    // thousands separator
    assertEqual('1,234', format_function.call(1234.123456, 0))
    assertEqual('12,345', format_function.call(12345.123456, 0))
    assertEqual('123,456', format_function.call(123456.123456, 0))
    assertEqual('1,234,567', format_function.call(1234567.123456, 0))
    assertEqual('12,345,678', format_function.call(12345678.123456, 0))
    assertEqual('123,456,789', format_function.call(123456789.123456, 0))
    assertEqual('-1,234', format_function.call(-1234.123456, 0))
    assertEqual('-12,345', format_function.call(-12345.123456, 0))
    assertEqual('-123,456', format_function.call(-123456.123456, 0))
    assertEqual('-1,234,567', format_function.call(-1234567.123456, 0))
    assertEqual('-12,345,678', format_function.call(-12345678.123456, 0))
    assertEqual('-123,456,789', format_function.call(-123456789.123456, 0))
    // thousands separator and decimal
    assertEqual('1,234.12', format_function.call(1234.123456, 2))
    assertEqual('12,345.12', format_function.call(12345.123456, 2))
    assertEqual('123,456.12', format_function.call(123456.123456, 2))
    assertEqual('1,234,567.12', format_function.call(1234567.123456, 2))
    assertEqual('12,345,678.12', format_function.call(12345678.123456, 2))
    assertEqual('123,456,789.12', format_function.call(123456789.123456, 2))
    assertEqual('-1,234.12', format_function.call(-1234.123456, 2))
    assertEqual('-12,345.12', format_function.call(-12345.123456, 2))
    assertEqual('-123,456.12', format_function.call(-123456.123456, 2))
    assertEqual('-1,234,567.12', format_function.call(-1234567.123456, 2))
    assertEqual('-12,345,678.12', format_function.call(-12345678.123456, 2))
    assertEqual('-123,456,789.12', format_function.call(-123456789.123456, 2))
}

console.log('======== Testing ========');
test(Number.prototype.format);
test(Number.prototype.format1);
test(Number.prototype.format2);
test(Number.prototype.format3);

बेंचमार्क

function benchmark(f) {
    var start = new Date().getTime();
    f();
    return new Date().getTime() - start;
}

function benchmark_format(f) {
    console.log(f);
    time = benchmark(function () {
        for (var i = 0; i < 100000; i++) {
            f.call(123456789, 0);
            f.call(123456789, 2);
        }
    });
    console.log(time.format(0) + 'ms');
}

// if not using async, browser will stop responding while running.
// this will create a new thread to benchmark
async = [];
function next() {
    setTimeout(function () {
        f = async.shift();
        f && f();
        next();
    }, 10);
}

console.log('======== Benchmark ========');
async.push(function () { benchmark_format(Number.prototype.format); });
next();







currency