मुद्रा स्ट्रिंग के रूप में संख्याओं को प्रारूपित कैसे करें?


1843

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

"$ 2,500.00"

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


8
formatNumberजावास्क्रिप्ट में कोई अंतर्निहित कार्य नहीं है
झटके

500
कृपया, भविष्य में इसे पढ़ने वाले किसी व्यक्ति के लिए, मुद्रा को संग्रहीत करने के लिए फ्लोट का उपयोग करें। आप सटीक और डेटा को ढीला कर देंगे। आपको इसे सेंट (या पेनी आदि) के पूर्णांक संख्या के रूप में संग्रहीत करना चाहिए और फिर आउटपुट से पहले परिवर्तित करना चाहिए।
फिलिप व्हाइटहाउस

8
@ user1308743 फ्लोट दशमलव स्थानों को संग्रहीत नहीं करता है। यह एक मान, आधार और ऑफसेट का उपयोग करके संख्याओं को संग्रहीत करता है। 0.01 वास्तव में प्रतिनिधित्व करने योग्य नहीं है। देखें: en.wikipedia.org/wiki/Floating_point#Accuracy_problems
फिलिप व्हाइटहाउस

6
@ user1308743: कल्पना कीजिए कि आप एक बहुत बड़ी संख्या का प्रतिनिधित्व करते हैं (कहते हैं कि आप एक भाग्यशाली व्यक्ति हैं और यह आपका बैंक खाता शेष है)। क्या आप वास्तव में एक सटीक कमी के कारण पैसा ढीला करना चाहेंगे?
ेरेऑन

163
तो किसी ने निम्नलिखित का सुझाव क्यों नहीं दिया? (2500) .toLocaleString ("एन-जीबी", {शैली: "मुद्रा", मुद्रा: "जीबीपी", न्यूनतम राशि: 2}) डेवलपर.
निक ग्रीली

जवाबों:


1790

Number.prototype.toFixed

यह समाधान हर एक प्रमुख ब्राउज़र के साथ संगत है:

  const profits = 2489.8237;

  profits.toFixed(3) //returns 2489.824 (rounds up)
  profits.toFixed(2) //returns 2489.82
  profits.toFixed(7) //returns 2489.8237000 (pads the decimals)

आपको बस मुद्रा चिन्ह (जैसे "$" + profits.toFixed(2)) जोड़ना है और आपकी राशि डॉलर में होगी।

कस्टम फ़ंक्शन

यदि आपको ,प्रत्येक अंक के बीच के उपयोग की आवश्यकता है , तो आप इस फ़ंक्शन का उपयोग कर सकते हैं:

function formatMoney(number, decPlaces, decSep, thouSep) {
decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,
decSep = typeof decSep === "undefined" ? "." : decSep;
thouSep = typeof thouSep === "undefined" ? "," : thouSep;
var sign = number < 0 ? "-" : "";
var i = String(parseInt(number = Math.abs(Number(number) || 0).toFixed(decPlaces)));
var j = (j = i.length) > 3 ? j % 3 : 0;

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

document.getElementById("b").addEventListener("click", event => {
  document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
});
<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
<br />
<button id="b">Get Output</button>
<p id="x">(press button to get output)</p>

इसका इस्तेमाल ऐसे करें:

(123456789.12345).formatMoney(2, ".", ",");

यदि आप हमेशा उपयोग करने जा रहे हैं '।' और ',', आप उन्हें अपने मेथड कॉल को छोड़ सकते हैं, और विधि उन्हें आपके लिए डिफ़ॉल्ट कर देगी।

(123456789.12345).formatMoney(2);

यदि आपकी संस्कृति के दो प्रतीक फ़्लिप किए गए हैं (यानी यूरोपीय) और आप डिफॉल्ट का उपयोग करना चाहते हैं, तो formatMoneyविधि में निम्नलिखित दो पंक्तियों पर पेस्ट करें :

    d = d == undefined ? "," : d, 
    t = t == undefined ? "." : t, 

कस्टम फ़ंक्शन (ES6)

यदि आप आधुनिक ECMAScript सिंटैक्स (यानी बैबल के माध्यम से) का उपयोग कर सकते हैं, तो आप इसके बजाय इस सरल फ़ंक्शन का उपयोग कर सकते हैं:

function formatMoney(amount, decimalCount = 2, decimal = ".", thousands = ",") {
  try {
    decimalCount = Math.abs(decimalCount);
    decimalCount = isNaN(decimalCount) ? 2 : decimalCount;

    const negativeSign = amount < 0 ? "-" : "";

    let i = parseInt(amount = Math.abs(Number(amount) || 0).toFixed(decimalCount)).toString();
    let j = (i.length > 3) ? i.length % 3 : 0;

    return negativeSign + (j ? i.substr(0, j) + thousands : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands) + (decimalCount ? decimal + Math.abs(amount - i).toFixed(decimalCount).slice(2) : "");
  } catch (e) {
    console.log(e)
  }
};
document.getElementById("b").addEventListener("click", event => {
  document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
});
<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
<br />
<button id="b">Get Output</button>
<p id="x">(press button to get output)</p>


26
सबसे पहले, उत्कृष्ट, संक्षिप्त कोड। हालांकि, अगर आप अमेरिकी हैं, तो आप की चूक बदलना चाहिए dऔर tहोना करने के लिए .और ,क्रमशः ताकि आप की जरूरत नहीं है कि उन्हें हर बार निर्दिष्ट करने के लिए। इसके अलावा, मैं returnपढ़ने के लिए बयान की शुरुआत को संशोधित करने की सलाह देता हूं : return s + '$' + [rest]अन्यथा, आपको डॉलर का संकेत नहीं मिलेगा।
जेसन

744
यकीन नहीं होता कि लोग इस कोड को सुंदर क्यों मानते हैं। यह अशोभनीय है। यह अच्छी तरह से काम करने लगता है, लेकिन यह सुंदर नहीं है।
usr

86
क्या यह फॉर्मेट मैनी फ़ंक्शन कुछ मिनिमाइज्ड जावास्क्रिप्ट कोड से कहीं कॉपी किया गया है? क्या आप मूल पोस्ट नहीं कर सकते? चर, d, i, j, n, s और t स्टैंड क्या हैं? Upvotes और टिप्पणियों की मात्रा को देखते हुए मैंने इस पोस्ट को मान लिया है कि इस कोड को हर जगह उत्पादन वेबसाइटों में चिपका दिया गया है ... यदि किसी दिन यह बग होता है तो कोड को बनाए रखना सौभाग्य है!
ज़ुलाउज़

259
"कविता"? अश्लीलता अधिक पसंद है। यह कोड गोल्फ नहीं है; थोड़ी सी सफेद जगह का उपयोग करें। उचित संस्करण नाम या तो चोट नहीं पहुँचाएगा।
कीथजग्रंट


1510

Intl.numberformat

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

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

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

जेएस की बेला

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

यहां मुद्रा कोड की एक सूची दी गई है

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 */

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

  • ब्राउज़र समर्थन अब वैश्विक स्तर पर 97.5% समर्थन के साथ, अमेरिका में 98% और ईयू में 99% के साथ एक मुद्दा नहीं है
  • वहां एक है जीवाश्म ब्राउज़रों पर इसका समर्थन करने के लिए शिम है (जैसे IE8), क्या आपको वास्तव में इसकी आवश्यकता होनी चाहिए
  • अधिक जानकारी के लिए CANIUse पर एक नज़र डालें

89
यह सरल जावास्क्रिप्ट, सरल और सुरुचिपूर्ण समाधान वही है जो मैं देख रहा था।
गुइलहेम सोलास

9
यह एक वोटिंग है क्योंकि यह एक मूर्खतापूर्ण सरल उत्तर है जो मूल रूप से काम करता है।
ट्रासिवा

17
बहुत यकीन है कि बहुत अधिक% ब्राउज़र अब इसका समर्थन करते हैं। इसे और अधिक बढ़ाना चाहिए।
flq

2
यह एक शानदार उत्तर है और मेरे पास इसे एक गतिशील मुद्रा मूल्य के साथ काम करना है इसलिए यदि उपयोग यूरोप में है तो यह EUR में बदल जाता है और यूरो चिन्ह दिखाता है। एक इलाज करता है!
Sprose

3
यह 2018 है और यह मूल रूप से हर जगह समर्थित है। यह सही उत्तर होना चाहिए।
सिपिंक 27'18

1340

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

(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/


21
मैं वास्तव में एक कदम आगे गया .replace(/(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,"):।
कलिजजुआ

4
VisioN और kalisjoshua regexp और दशमलव स्थान निर्दिष्ट करने के तरीके के साथ कॉफीस्क्रिप्ट संस्करण (ताकि आप 2 का डिफ़ॉल्ट छोड़ सकते हैं या कोई दशमलव के लिए 0 निर्दिष्ट कर सकते हैं):Number.prototype.toMoney = (decimal=2) -> @toFixed(decimal).replace /(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,"
Eric Anderson

11
@ अब्बास हाँ, (पंक्ति के अंत) के \.साथ बदलें $, अर्थात this.toFixed(0).replace(/(\d)(?=(\d{3})+$)/g, "$1,")
VisioN

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

2
@ JuliendePrabère कृपया एक लंबी संख्या का उदाहरण दें, जो इस दृष्टिकोण के साथ काम नहीं करती है।
VisioN

248

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

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

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

उदाहरण:

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

2
धन्यवाद! इस विचार के आधार पर मैं एक बनाने में सक्षम था जो कि छोटा और काफी सरल है! (और स्थानीयकृत) उत्कृष्ट।
बजे डैनियल मैगियोला

7
वास्तव में आप कर सकते हैं। डॉलर के लिए अर्थात: '$' + (मान + 0.001) .LococaleString ()। स्लाइस (0, -1)
ज़ाप्री

6
ऐसा लगता है कि यह बहुत अच्छा होगा, लेकिन इस समय बहुत कम ब्राउज़र सपोर्ट है
acorncom

1
@acorncom आप क्यों कहते हैं कि "थोड़ा ब्राउज़र समर्थन" है? जावास्क्रिप्ट 1.1 के बाद से संख्या वस्तु आसपास रही है। कृपया एक संदर्भ प्रदान करें जो आपके दावे का समर्थन करता है।
डग एस

2
ध्यान रखा जाना चाहिए कि toLocaleStringसिस्टम लोकेल का उपयोग करने का एक पुराना संस्करण है , और एक नया (असंगत) जो ECMAScript Intl API से आता है। यहाँ समझाया गया । यह उत्तर पुराने संस्करण के लिए अभिप्रेत लगता है।
aross

162

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

/* 
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 [/programming/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'सुझाव के रूप में उपयोग करते हैं कैसे सबसे अच्छा निर्धारित करने के लिए एक तर्क जावास्क्रिप्ट समारोह को नहीं भेजी जाती

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

जेएस फिडल


8
आप parseInt में मूलांक के रूप में '10' का उपयोग करना चाह सकते हैं। अन्यथा, कोई भी संख्या जो '0' से शुरू होती है, ऑक्टल नंबरिंग का उपयोग करेगी।
sohtimsso1970

3
@ sohtimsso1970: देर से प्रतिक्रिया के लिए खेद है, लेकिन क्या आप कुछ और समझा सकते हैं? मैं नहीं देखता कि अष्टक के रूप में एक संख्या की व्याख्या कहां की जा सकती है। parseIntसंख्या के पूर्णांक भाग का निरपेक्ष मान पर कहा जाता है। INTEGER हिस्सा ZERO से शुरू नहीं हो सकता जब तक कि यह सिर्फ एक ZERO न हो! और parseInt(0) === 0या तो अष्टाधारी या दशमलव।
मार्को डेमायो

उदाहरण के लिए प्रयास करें: parseInt ("016") ... 14 देता है, क्योंकि parseInt मानता है कि यह अष्टकोण है, जब स्ट्रिंग शून्य से शुरू होती है।
ट्रैकर 1

4
@ Tracker1: मैं समझता था कि एक संख्या जिसकी शुरुआत 0अष्टक द्वारा मानी जाती है parseInt। लेकिन इस कोड में इनपुट के रूप में parseIntप्राप्त करने के लिए IMPOSSIBLE है 016(या किसी भी अन्य अष्टाधारी स्वरूपित मूल्य), क्योंकि तर्क दिया गया parseIntहै 1 Math.absफ़ंक्शन द्वारा संसाधित किया गया है। इसलिए parseIntएक संख्या प्राप्त करने का कोई तरीका नहीं है जो शून्य से शुरू होता है जब तक कि यह सिर्फ एक शून्य या 0.nn(जहां nnदशमलव न हो)। लेकिन दोनों 0और 0.nnतार parseIntको एक सादे शून्य में बदल दिया जाएगा जैसा कि माना जाता है।
मार्को डेमायो

यह फ़ंक्शन गलत हैं:> (2030) .toMoney (0, ',', ''); <"2 03 0"
एंटोन पी रॉबुल

124

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


... बस एक मुद्रा प्रतीक को पास करना याद रखें अन्यथा IE7 और IE8 में त्रुटियां होती हैं, IE9 किसी भी तरह से ठीक है
वेक्टर

2
ऐसा लगता है कि IE7 / IE8 बग तय हो गया है।
Mat Schaffer

2
यह एक महान पुस्तकालय है, मुद्रा प्रतीक को पारित करने में सक्षम होना भी एक अच्छा विचार है, क्योंकि सभी मुद्रा विवरण एकल फ़ंक्शन कॉल / सेटिंग्स में निहित हैं
farinspace

2
मुझे यह तथ्य पसंद है कि आप रिवर्स कर सकते हैं - एक प्रारूपित मुद्रा स्ट्रिंग पास करें और संख्यात्मक मान प्राप्त करें।
नील मुनरो

2
लेखांकन .js हाल ही में बनाए रखा प्रतीत नहीं होता है। हाल के परिवर्तनों के साथ एक कांटा है github.com/nashdot/accounting-js
RationalDev को GoFundMonica

124

यदि राशि एक संख्या है -123, तो कहें

amount.toLocaleString('en-US', { style: 'currency', currency: 'USD' });

स्ट्रिंग का उत्पादन करेगा "-$123.00"

यहां पूरा काम करने का उदाहरण है


7
यह उत्तर मेरे लिए लगभग था, लेकिन मुझे इसकी आवश्यकता थी कि इसे निकटतम पेनी के लिए बनाया जाए। यह वह है जो मैंने राशि का उपयोग किया था ।toLocaleString ('एन-जीबी', {शैली: 'मुद्रा', मुद्रा: 'जीबीपी', मैक्सफ़्रेक्शनडिजिट्स: 2});
निको

उपरोक्त कोड आपके इच्छित अंकों की संख्या के लिए राउंडिंग करता है। उदाहरण देखें और इनपुट बॉक्स में 1.237 टाइप करें।
डैनियल बारबलेस

3
सफारी में काम करने के लिए प्रतीत नहीं होता है। यह बिना किसी स्वरूपण के केवल एक स्ट्रिंग के रूप में संख्या देता है।
लांस एंडरसन

1
वाह, यह एक बहुत अच्छा जवाब है। अव्वल होना चाहिए।
ईथन

2
यदि किसी कारण से आप सेंट नहीं चाहते हैं, तो आप दशमलव सटीकता को बदल सकते हैं:minimumFractionDigits: 0
होरासियो

99

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

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://stackoverflow.com/a/149099/751484

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

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

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


6
@hacklikecrack, सभी चर स्थानीय हैं; वे varबयान में हैं।
जोनाथन एम

3
क्षमा करें, हां, हालांकि आप तर्कों को पुनर्विकसित कर रहे हैं। खरोज! ;)
हैकलीक्रेक

चर नामों का भयानक उपयोग!
सर्ज सगन

77

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

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"

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


कविता। प्रतिभाशाली। क्या आपने कम करने की कोशिश की है () developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… जो रिवर्स () को खत्म करना चाहिए?
स्टीव

1
@Steve - आप सही हैं, लेकिन आपको i = orig.length - i - 1कॉलबैक में कुछ करने की आवश्यकता होगी । फिर भी, सरणी का एक कम ट्रैवर्सल।
वेन

11
reduceकॉम्पेटिबिलिटी के बारे में नहीं: विधि को एक्मास्क्रिप्ट १. and में पेश किया गया था, और यह इंटरनेट एक्सप्लोरर: और नीचे में समर्थित नहीं है।
१०’१२

@Blaise ने कहा, यह विधि IE 8 या उससे नीचे में काम नहीं करेगी।
rsbarro

हां, यह सही है। जैसा कि उत्तर में ही बताया गया है, यह केवल मनोरंजन के लिए है। इसके अलावा, यह ठीक ठीक नकारात्मक संख्या को संभालना चाहिए।
वेन

76

सभी वर्तमान ब्राउज़रों के लिए काम करता है

toLocaleStringभाषा-संवेदनशील प्रतिनिधित्व में एक मुद्रा को प्रारूपित करने के लिए उपयोग करें ( आईएसओ 4217 मुद्रा कोड का उपयोग करके )।

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

उदाहरण दक्षिण अफ्रीकी रैंड कोड @avenmore के लिए स्निपेट

console.log((2500).toLocaleString("en-ZA", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> R 2 500,00
console.log((2500).toLocaleString("en-GB", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> ZAR 2,500.00


1
क्योंकि 'लोकेशन' और 'विकल्प' तर्क क्रोम के 24, IE11 और ओपेरा 15. फ़ायरफ़ॉक्स, सफारी और अन्य के पुराने संस्करणों की तरह ही अभी भी इसका समर्थन नहीं करते हैं।
VisioN

3
सहमत, यह सभी ब्राउज़रों (अभी तक) में पूरी तरह से समर्थित नहीं है, लेकिन यह अभी भी एक समाधान है। (और निश्चित रूप से सबसे वैध समाधान, गैर-समर्थित ब्राउज़रों के साथ इसके आगे संगत के रूप में, और यह जावास्क्रिप्ट एपीआई की एक प्रलेखित विशेषता है।)
निक ग्रीली

1
मुझे यह पसंद है और मुझे खुशी है कि यह भारतीय अंकों के समूह के साथ काम करता है।
MSC

7
यह पूरी तरह से 2017 के रूप में समर्थित है और एकमात्र सही उत्तर होना चाहिए
एवगेनी

1
नवीनतम और सबसे बड़ा :) FF69, Chrome76, आदि "आर 2 500,00" वह नहीं है जो हम यहां उपयोग करते हैं, यह "आर 2,500.00" होना चाहिए, एन-जीबी के समान।
एवेंमोर

70

मुझे लगता है कि तुम क्या चाहते हो f.nettotal.value = "$" + showValue.toFixed(2);


@ इस कार्य को क्रश करें, लेकिन यह अब कर क्षेत्र की गणना नहीं करता है?
रोक्को द टैको

11
एक बार जब आप इसे $ साइन करते हैं, तो यह अब एक संख्या नहीं है, बल्कि एक स्ट्रिंग है।
क्रश करें

यह विकल्प हजारों लोगों के बीच अल्पविराम नहीं रखता है। :-(
साइमन ईस्ट

29

Numeral.js - @adamwdraper द्वारा आसान संख्या स्वरूपण के लिए एक js लाइब्रेरी

numeral(23456.789).format('$0,0.00'); // = "$23,456.79"

Fork Numbro को और अधिक प्यार मिलता है क्योंकि Numeral.js को छोड़ दिया लगता है: github.com/foretagsplatsen/numbro
RationalDev को GoFundMonica

Numeral.js फिर से सक्रिय है।
adamwdraper

27

ठीक है, आपने जो कहा, उसके आधार पर, मैं इसका उपयोग कर रहा हूं:

var DecimalSeparator = Number("1.2").toLocaleString().substr(1,1);

var AmountWithCommas = Amount.toLocaleString();
var arParts = String(AmountWithCommas).split(DecimalSeparator);
var intPart = arParts[0];
var decPart = (arParts.length > 1 ? arParts[1] : '');
decPart = (decPart + '00').substr(0,2);

return '£ ' + intPart + DecimalSeparator + decPart;

मैं सुधार के सुझावों के लिए खुला हूं (मैं ऐसा करने के लिए YUI को शामिल नहीं करना पसंद करूंगा :-)) मुझे पहले से ही पता है कि मुझे "पता लगाना" चाहिए। इसे केवल दशमलव विभाजक के रूप में उपयोग करने के बजाय ...


8
ध्यान दें कि आपका संस्करण दो दशमलव अंकों तक ठीक से गोल नहीं है। उदाहरण के लिए, 3.706 को "£ 3.70" के रूप में स्वरूपित किया जाएगा, न कि "£ 3.71" के रूप में जैसा कि यह माना जाता है।
अत्स गोराल सेप

हां, यह मेरे विशेष मामले में ठीक है, क्योंकि मैं जिन राशियों के साथ काम कर रहा हूं, उनमें पहले से ही अधिकांश 2 अंक हैं। मुझे जो 2 दशमलव तक तय करने की जरूरत है, वह बिना किसी परिमाण के राशि के साथ या केवल 1 के साथ है।
डैनियल मैगिओला

26

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

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


3
वाह, यह अधिक उत्थान क्यों नहीं है? सभी प्रकार के स्वरूपण के लिए बड़ा मानकीकृत पुस्तकालय। सही वैश्वीकरण के साथ उद्योग-मानक स्वरूपण पैरामीटर। बहुत बढ़िया जवाब!!
पबरानीस

यह अभी भी अल्फा चरण माना जाता है, इसलिए सावधानी से उपयोग करें, लेकिन महान खोज।
नील मुनरो

1
अब अल्फा (या बीटा) में नहीं है। जब हम सफारी के लिए नए मानक को पूरा करने और IE <11 को मरने के लिए इंतजार करते हैं तो यह बहुत उपयोगी लगता है।
गाइ शालनाट

25

जावास्क्रिप्ट-संख्या-फ़ॉर्मेटर (पहले Google कोड में )

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

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


23

मूल विधि प्रदान करने के लिए जोनाथन एम को +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) : "");
};

पहला संस्करण थोड़े अजीब है, क्योंकि वे चर पहले से ही फ़ंक्शन घोषणा में घोषित किए गए हैं। इसके अलावा, धन्यवाद!
रिच ब्रैडशॉ

2
आप सही हे। यह एक त्रुटि है जो मैं जोनाथन एम के मूल से लाया हूं, जहां वे सभी एक एकल संस्करण अभिव्यक्ति के रूप में जंजीर हैं। वे सरल कार्य होने चाहिए। फिक्सिंग।
एक्सएमएल

उस बात के लिए, मुझे लगता है कि यह शायद समय से पहले अनुकूलित है और पठनीयता के लिए फिर से बनाया जाना चाहिए। लेकिन मेरा लक्ष्य ओपी के कोड को बढ़ाना था, न कि इसे मौलिक रूप से बदलना।
एक्सएमएल

यह बहुत बुरा नहीं है - +n || 0केवल एक चीज है जो थोड़ा अजीब लगता है (मुझे वैसे भी)।
रिच ब्रैडशॉ

2
thisएक पूरी तरह से उपयोगी चर नाम है। इसे परिवर्तित करने से nआप 3 वर्णों को बचा सकते हैं परिभाषा के समय एक युग में आवश्यक हो सकता है जब रैम और बैंडविड्थ को केबी में गिना जाता था, लेकिन एक युग में केवल इतना ही अप्रिय होता है जब मिनीफ़ायर सभी का ध्यान रखेगा कि इससे पहले कि यह कभी भी उत्पादन को हिट करे। अन्य चतुर सूक्ष्म-अनुकूलन कम से कम बहस योग्य हैं।
एक्सएमएल

22

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'

यह केवल एक सही कार्य है:> नंबर_फॉर्मेट (2030, 0, '', '') <'2 030' ग्रेट! धन्यवाद
एंटोन पी। रोबुल


20

ऐसा कुछ नहीं देखा। यह काफी संक्षिप्त और समझने में आसान है।

function moneyFormat(price, sign = '$') {
  const pieces = parseFloat(price).toFixed(2).split('')
  let ii = pieces.length - 3
  while ((ii-=3) > 0) {
    pieces.splice(ii, 0, ',')
  }
  return sign + pieces.join('')
}

console.log(
  moneyFormat(100),
  moneyFormat(1000),
  moneyFormat(10000.00),
  moneyFormat(1000000000000000000)
)

यहां अंतिम आउटपुट में अधिक विकल्पों के साथ एक संस्करण है जो विभिन्न इलाकों में विभिन्न मुद्राओं को प्रारूपित करने की अनुमति देता है।

// higher order function that takes options then a price and will return the formatted price
const makeMoneyFormatter = ({
  sign = '$',
  delimiter = ',',
  decimal = '.',
  append = false,
  precision = 2,
  round = true,
  custom
} = {}) => value => {
  
  const e = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]
  
  value = round
    ? (Math.round(value * e[precision]) / e[precision])
    : parseFloat(value)
  
  const pieces = value
    .toFixed(precision)
    .replace('.', decimal)
    .split('')
  
  let ii = pieces.length - (precision ? precision + 1 : 0)
  
  while ((ii-=3) > 0) {
    pieces.splice(ii, 0, delimiter)
  }
  
  if (typeof custom === 'function') {
    return custom({
      sign,
      float: value, 
      value: pieces.join('') 
    })
  }
  
  return append
    ? pieces.join('') + sign
    : sign + pieces.join('')
}

// create currency converters with the correct formatting options
const formatDollar = makeMoneyFormatter()
const formatPound = makeMoneyFormatter({ 
  sign: '£',
  precision: 0
})
const formatEuro = makeMoneyFormatter({
  sign: '€',
  delimiter: '.',
  decimal: ',',
  append: true
})

const customFormat = makeMoneyFormatter({
  round: false,
  custom: ({ value, float, sign }) => `SALE:$${value}USD`
})

console.log(
  formatPound(1000),
  formatDollar(10000.0066),
  formatEuro(100000.001),
  customFormat(999999.555)
)


महान कोड स्निपेट, धन्यवाद। हालांकि, सावधान रहें, क्योंकि यह IE पर काम नहीं करेगा क्योंकि डिफ़ॉल्ट पैरामीटर समर्थित नहीं हैं, और <IE11 में "कॉन्स्ट" और "लेट" समर्थित नहीं हैं। इसे ठीक करने के लिए Ue: + moneyFormat: function (price, sign) {+ if (साइन!) Sign = '$'; + टुकड़े = parseFloat (मूल्य) .toFixed (2) .plplit ('') + var ii = pieces.length - 3
चार्ली डलास

कोई चिंता नहीं @CharlieDalsass। मैं उत्पादन कोड के लिए ES5 के लिए इसे संकलित करने के लिए बैबेल का उपयोग करने की सलाह दूंगा।
सिंथेट

लेकिन यूरो मुद्रा कैसे करें? 1.000,00 यूरो?

@YumYumYum I ने अधिक लचीलेपन की अनुमति देने के लिए अधिक स्वरूपण विकल्पों के साथ एक पूर्ण उदाहरण जोड़ा।
सिंथेट

18

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

// 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];
}

मुझे ब्राउज़र और नोड के पुराने संस्करण में काम करने के लिए कुछ चाहिए था। यह पूरी तरह से काम किया। धन्यवाद
n8jadams

17

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

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

Ins1000Sep () में नकारात्मक मान दर्ज करते हुए मुझे गलत संख्या आउटपुट मिलता है।
पीटर

16

एक अंतर्निहित function इनफिक्स हैjavascript

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

यह उत्तर बेमानी लगता है। क्रश के जवाब में पहले से ही उल्लेख हैtoFixed()
इयान डन

3
toFixed()Numberवस्तु का एक कार्य है और var numअगर यह एक था पर काम नहीं करेगा String, तो अतिरिक्त संदर्भ ने मेरी मदद की।
टिम्बोर्डेन

15
function CurrencyFormatted(amount)
{
    var i = parseFloat(amount);
    if(isNaN(i)) { i = 0.00; }
    var minus = '';
    if(i < 0) { minus = '-'; }
    i = Math.abs(i);
    i = parseInt((i + .005) * 100);
    i = i / 100;
    s = new String(i);
    if(s.indexOf('.') < 0) { s += '.00'; }
    if(s.indexOf('.') == (s.length - 2)) { s += '0'; }
    s = minus + s;
    return s;
}

से WillMaster


छोटा और सरल। धन्यवाद।
कॉनर सिम्पसन

1
सरल, लेकिन 1,000 के लिए कोई कॉमा नहीं
एरॉन

15

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

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

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

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

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


14

यह थोड़ी देर हो सकती है, लेकिन यहाँ एक विधि है जो मैंने .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"

12

आमतौर पर, एक ही काम करने के कई तरीके हैं, लेकिन मैं 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 को संपादित: दशमलव अंकों की संख्या को शून्य पर सेट करने का विकल्प जोड़ा गया।


ToLocaleString की बात यह है कि यह उपयोगकर्ता की सेटिंग के साथ समायोजित करता है।
जोसेफ लेनोक्स

11

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

विधि 0 (RegExp)

आधार पर https://stackoverflow.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();

अपने तरीके से सुधरी हुई 2. var a = this.toFixed (परिशुद्धता) .split ('।') से var गुणक = Math.pow (10, परिशुद्धता + 1), पूरेNumber = Math.floor (यह * गुणक) में परिवर्तन करें। ; var a = Math.round (सम्पूर्ण / 10) * 10 / गुणक; if (String (a) .indexOf ('।') <1) {a + = '.00'; } a = String (a) .split ('।'), toFixed का उपयोग न करें क्योंकि यह छोटी गाड़ी है।
वेट

console.log (parseFloat ( '4.835') toFixed (2)।); > 4.83 कंसोल.लॉग (parseFloat ('54 .835 ')। toFixed (2)); > 54.84 कंसोल.लॉग (parseFloat ('454.835')। toFixed (2)); > 454.83 कंसोल.लॉग (parseFloat ('8454.835')। toFixed (2)); > 8454.83 इन सभी मानों का दशमलव .84 नहीं .83
vee


10

स्ट्रिंग पहले और मूल regexp को उल्टा करके उचित कॉमा प्लेसमेंट के लिए एक सरल विकल्प।

String.prototype.reverse = function() {
    return this.split('').reverse().join('');
};

Number.prototype.toCurrency = function( round_decimal /*boolean*/ ) {       
     // format decimal or round to nearest integer
     var n = this.toFixed( round_decimal ? 0 : 2 );

     // convert to a string, add commas every 3 digits from left to right 
     // by reversing string
     return (n + '').reverse().replace( /(\d{3})(?=\d)/g, '$1,' ).reverse();
};

10

मुझे यह मिला: लेखांकनजेएस इसकी बहुत आसान और पूरी तरह से मेरी जरूरत है।

// 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€ 


$('#price').val( accounting.formatMoney(OOA, { symbol: "€", precision: 2,thousand: ".", decimal :",",format: "%v%s" } ) );- शो 1.000,00 ई
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.